Committing AXIOM code in to ws-commons
diff --git a/src/org/apache/ws/commons/attachments/ByteArrayDataSource.java b/src/org/apache/ws/commons/attachments/ByteArrayDataSource.java
new file mode 100644
index 0000000..8fbe840
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/ByteArrayDataSource.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import javax.activation.DataSource;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class ByteArrayDataSource implements DataSource {
+
+ private byte[] data;
+
+ private String type;
+
+ public ByteArrayDataSource(byte[] data, String type) {
+ super();
+ this.data = data;
+ this.type = type;
+ }
+
+ public ByteArrayDataSource(byte[] data) {
+ super();
+ this.data = data;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public String getContentType() {
+ if (type == null)
+ return "application/octet-stream";
+ else
+ return type;
+ }
+
+ public InputStream getInputStream() throws IOException {
+ return new ByteArrayInputStream(data);
+ }
+
+ public String getName() {
+
+ return "ByteArrayDataSource";
+ }
+
+ public OutputStream getOutputStream() throws IOException {
+ throw new IOException("Not Supported");
+ }
+}
+
diff --git a/src/org/apache/ws/commons/attachments/DataHandlerUtils.java b/src/org/apache/ws/commons/attachments/DataHandlerUtils.java
new file mode 100644
index 0000000..b3a4a64
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/DataHandlerUtils.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2004 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+
+import org.apache.ws.commons.om.util.Base64;
+
+import javax.activation.DataHandler;
+
+public class DataHandlerUtils {
+
+ public static Object getDataHandlerFromText(String value, String mimeType)
+ {
+ ByteArrayDataSource dataSource;
+ byte[] data = Base64.decode(value);
+ if (mimeType != null) {
+ dataSource = new ByteArrayDataSource(data, mimeType);
+ } else {
+ // Assumes type as application/octet-stream
+ dataSource = new ByteArrayDataSource(data);
+ }
+ return new DataHandler(dataSource);
+ }
+}
diff --git a/src/org/apache/ws/commons/attachments/MIMEBodyPartInputStream.java b/src/org/apache/ws/commons/attachments/MIMEBodyPartInputStream.java
new file mode 100644
index 0000000..dc6a846
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/MIMEBodyPartInputStream.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+
+public class MIMEBodyPartInputStream extends InputStream {
+ PushbackInputStream inStream;
+
+ boolean boundaryFound;
+
+ MIMEHelper parent;
+
+ byte[] boundary;
+
+ public MIMEBodyPartInputStream(PushbackInputStream inStream, byte[] boundary) {
+ super();
+ this.inStream = inStream;
+ this.boundary = boundary;
+ }
+
+ public MIMEBodyPartInputStream(PushbackInputStream inStream,
+ byte[] boundary, MIMEHelper parent) {
+ this(inStream, boundary);
+ this.parent = parent;
+ }
+
+ public int read() throws IOException {
+ if (boundaryFound) {
+ return -1;
+ }
+ // read the next value from stream
+ int value = inStream.read();
+
+ // A problem occured because all the mime parts tends to have a /r/n at
+ // the end. Making it hard to transform them to correct DataSources.
+ // This logic introduced to handle it
+ //TODO look more in to this && for a better way to do this
+ if (value == 13) {
+ value = inStream.read();
+ if (value != 10) {
+ inStream.unread(value);
+ return 13;
+ } else {
+ value = inStream.read();
+ if ((byte) value != boundary[0]) {
+ inStream.unread(value);
+ inStream.unread(10);
+ return 13;
+ }
+ }
+ } else if ((byte) value != boundary[0]) {
+ return value;
+ }
+
+ // read value is the first byte of the boundary. Start matching the
+ // next characters to find a boundary
+ int boundaryIndex = 0;
+ while ((boundaryIndex < (boundary.length - 1))
+ && ((byte) value == boundary[boundaryIndex])) {
+ value = inStream.read();
+ boundaryIndex++;
+ }
+
+ if (boundaryIndex == (boundary.length - 1)) { // boundary found
+ boundaryFound = true;
+ // read the end of line character
+ if ((value = inStream.read()) == 45) {
+ //check whether end of stream
+ //Last mime boundary should have a succeeding "--"
+ if ((value = inStream.read()) == 45 && parent!=null) {
+ parent.setEndOfStream(true);
+ }
+ } else {
+ inStream.read();
+ }
+
+ return -1;
+ }
+
+ // Boundary not found. Restoring bytes skipped.
+ // write first skipped byte, push back the rest
+
+ if (value != -1) { // Stream might have ended
+ inStream.unread(value);
+ }
+ inStream.unread(boundary, 1, boundaryIndex - 1);
+ return boundary[0];
+ }
+
+ public boolean getBoundaryStatus()
+ {
+ return boundaryFound;
+ }
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/attachments/MIMEHelper.java b/src/org/apache/ws/commons/attachments/MIMEHelper.java
new file mode 100644
index 0000000..dff3871
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/MIMEHelper.java
@@ -0,0 +1,405 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.impl.MTOMConstants;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.activation.DataHandler;
+import javax.mail.MessagingException;
+import javax.mail.internet.ContentType;
+import javax.mail.internet.ParseException;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.util.HashMap;
+
+public class MIMEHelper {
+
+ /**
+ * <code>ContentType</code> of the MIME message
+ */
+ ContentType contentType;
+
+ /**
+ * Mime <code>boundary</code> which separates mime parts
+ */
+ byte[] boundary;
+
+ /**
+ * <code>applicationType</code> used to distinguish between MTOM & SWA If
+ * the message is MTOM optimised type is application/xop+xml If the message
+ * is SWA, type is ??have to find out
+ */
+ String applicationType;
+
+ /**
+ * <code>pushbackInStream</code> stores the reference to the incoming
+ * stream A PushbackStream has the ability to "push back" or "unread" one
+ * byte.
+ */
+ PushbackInputStream pushbackInStream;
+
+ /**
+ * <code>mimeBodyPartsMap</code> stores the already parsed Mime Body
+ * Parts. This Map will be keyed using the content-ID's
+ */
+ HashMap bodyPartsMap;
+
+ /**
+ * <code>partIndex</code>- Number of Mime parts parsed
+ */
+ int partIndex = 0;
+
+ /**
+ * <code>endOfStreamReached</code> flag which is to be set by
+ * MIMEBodyPartStream when MIME message terminator is found.
+ */
+ boolean endOfStreamReached;
+
+ String firstPartId;
+
+ boolean fileCacheEnable;
+
+ String attachmentRepoDir;
+
+ int fileStorageThreshold;
+
+ protected Log log = LogFactory.getLog(getClass());
+
+
+ /**
+ * Moves the pointer to the beginning of the first MIME part. Reads
+ * till first MIME boundary is found or end of stream is reached.
+ *
+ * @param inStream
+ * @param contentTypeString
+ * @param fileCacheEnable
+ * @param attachmentRepoDir
+ * @throws OMException
+ */
+ public MIMEHelper(InputStream inStream, String contentTypeString,
+ boolean fileCacheEnable, String attachmentRepoDir,
+ String fileThreshold) throws OMException {
+ this.attachmentRepoDir = attachmentRepoDir;
+ this.fileCacheEnable = fileCacheEnable;
+ if (fileThreshold != null && (!"".equals(fileThreshold))) {
+ this.fileStorageThreshold = Integer.parseInt(fileThreshold);
+ } else {
+ this.fileStorageThreshold = 1;
+ }
+ bodyPartsMap = new HashMap();
+ try {
+ contentType = new ContentType(contentTypeString);
+ } catch (ParseException e) {
+ throw new OMException(
+ "Invalid Content Type Field in the Mime Message"
+ ,e);
+ }
+ // Boundary always have the prefix "--".
+ this.boundary = ("--" + contentType.getParameter("boundary"))
+ .getBytes();
+
+ // do we need to wrap InputStream from a BufferedInputStream before
+ // wrapping from PushbackStream
+ pushbackInStream = new PushbackInputStream(inStream,
+ (this.boundary.length + 2));
+
+ // Move the read pointer to the beginning of the first part
+ // read till the end of first boundary
+ while (true) {
+ int value;
+ try {
+ value = pushbackInStream.read();
+ if ((byte) value == boundary[0]) {
+ int boundaryIndex = 0;
+ while ((boundaryIndex < boundary.length)
+ && ((byte) value == boundary[boundaryIndex])) {
+ value = pushbackInStream.read();
+ if (value == -1)
+ throw new OMException(
+ "Unexpected End of Stream while searching for first Mime Boundary");
+ boundaryIndex++;
+ }
+ if (boundaryIndex == boundary.length) { // boundary found
+ pushbackInStream.read();
+ break;
+ }
+ } else if ((byte) value == -1) {
+ throw new OMException(
+ "Mime parts not found. Stream ended while searching for the boundary");
+ }
+ } catch (IOException e1) {
+ throw new OMException("Stream Error" + e1.toString(), e1);
+ }
+ }
+ }
+
+ /**
+ * Sets file cache to false.
+ *
+ * @param inStream
+ * @param contentTypeString
+ * @throws OMException
+ */
+ public MIMEHelper(InputStream inStream, String contentTypeString)
+ throws OMException {
+ this(inStream, contentTypeString, false, null, null);
+ }
+
+ /**
+ * @return whether Message Type is SOAP with Attachments or MTOM optimized,
+ * by checking the application type parameter in the Content Type.
+ */
+ public String getAttachmentSpecType() {
+ if (this.applicationType == null) {
+ applicationType = contentType.getParameter("type");
+ if ((MTOMConstants.MTOM_TYPE).equalsIgnoreCase(applicationType)) {
+ this.applicationType = MTOMConstants.MTOM_TYPE;
+ } else if ((MTOMConstants.SWA_TYPE).equalsIgnoreCase(applicationType)) {
+ this.applicationType = MTOMConstants.SWA_TYPE;
+ } else {
+ throw new OMException(
+ "Invalid Application type. Support available for MTOM/SOAP 1.2 & SwA/SOAP 1.l only.");
+ }
+ }
+ return this.applicationType;
+ }
+
+ /**
+ * @return the InputStream which includes the SOAP Envelope. It assumes that
+ * the root mime part is always pointed by "start" parameter in
+ * content-type.
+ */
+ public InputStream getSOAPPartInputStream() throws OMException {
+ DataHandler dh;
+ try {
+ dh = getDataHandler(getSOAPPartContentID());
+ if (dh == null) {
+ throw new OMException(
+ "Mandatory Root MIME part containing the SOAP Envelope is missing");
+ }
+ return dh.getInputStream();
+ } catch (IOException e) {
+ throw new OMException(
+ "Problem with DataHandler of the Root Mime Part. ",e);
+ }
+ }
+
+ /**
+ * @return the Content-ID of the SOAP part It'll be the value Start
+ * Parameter of Content-Type header if given in the Content type of
+ * the MIME message. Else it'll be the content-id of the first MIME
+ * part of the MIME message
+ */
+ private String getSOAPPartContentID() {
+ String rootContentID = contentType.getParameter("start");
+
+ // to handle the Start parameter not mentioned situation
+ if (rootContentID == null) {
+ if (partIndex == 0) {
+ getNextPart();
+ }
+ rootContentID = firstPartId;
+ } else {
+ rootContentID.trim();
+
+ if ((rootContentID.indexOf("<") > -1)
+ & (rootContentID.indexOf(">") > -1))
+ rootContentID = rootContentID.substring(1, (rootContentID
+ .length() - 1));
+ }
+ // Strips off the "cid" part from content-id
+ if ("cid".equalsIgnoreCase(rootContentID.substring(0, 3))) {
+ rootContentID = rootContentID.substring(4);
+ }
+ return rootContentID;
+ }
+
+ public String getSOAPPartContentType() {
+ Part soapPart = getPart(getSOAPPartContentID());
+ try {
+ return soapPart.getContentType();
+ } catch (MessagingException e) {
+ log.error(e.getMessage());
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * @param blobContentID
+ * (without the surrounding angle brackets and "cid:" prefix)
+ * @return The DataHandler of the mime part referred by the Content-Id
+ * @throws OMException
+ */
+ public DataHandler getDataHandler(String blobContentID) throws OMException {
+
+ try {
+ return getPart(blobContentID).getDataHandler();
+ } catch (MessagingException e) {
+ throw new OMException("Problem with Mime Body Part No " + partIndex
+ + ". ", e);
+ }
+
+ }
+
+ /**
+ * Checks whether the MIME part is already parsed by checking the
+ * parts HashMap. If it is not parsed yet then call the getNextPart()
+ * till the required part is found.
+ *
+ * @param blobContentID
+ * @return The Part referred by the Content-Id
+ * @throws OMException
+ *
+ */
+ public Part getPart(String blobContentID) {
+ Part bodyPart;
+ if (bodyPartsMap.containsKey(blobContentID)) {
+ bodyPart = (Part) bodyPartsMap.get(blobContentID);
+ return bodyPart;
+ } else {
+ //This loop will be terminated by the Exceptions thrown if the Mime
+ // part searching was not found
+ while (true) {
+ bodyPart = this.getNextPart();
+ if (bodyPart == null) {
+ return null;
+ }
+ if (bodyPartsMap.containsKey(blobContentID)) {
+ bodyPart = (Part) bodyPartsMap.get(blobContentID);
+ return bodyPart;
+ }
+ }
+ }
+ }
+
+ protected void setEndOfStream(boolean value) {
+ this.endOfStreamReached = value;
+
+ }
+
+ /**
+ * @return the Next valid MIME part + store the Part in the Parts List
+ * @throws OMException
+ * throw if content id is null or if two MIME parts contain the
+ * same content-ID & the exceptions throws by getPart()
+ */
+ private Part getNextPart() throws OMException {
+ Part nextPart;
+ nextPart = getPart();
+ if (nextPart != null) {
+ String partContentID;
+ try {
+ partContentID = nextPart.getContentID();
+
+ if (partContentID == null & partIndex == 1) {
+ bodyPartsMap.put("firstPart", nextPart);
+ firstPartId = "firstPart";
+ return nextPart;
+ }
+ if (partContentID == null) {
+ throw new OMException(
+ "Part content ID cannot be blank for non root MIME parts");
+ }
+ if ((partContentID.indexOf("<") > -1)
+ & (partContentID.indexOf(">") > -1)) {
+ partContentID = partContentID.substring(1, (partContentID
+ .length() - 1));
+
+ } else if (partIndex == 1) {
+ firstPartId = partContentID;
+ }
+ if (bodyPartsMap.containsKey(partContentID)) {
+ throw new OMException(
+ "Two MIME parts with the same Content-ID not allowed.");
+ }
+ bodyPartsMap.put(partContentID, nextPart);
+ return nextPart;
+ } catch (MessagingException e) {
+ throw new OMException("Error reading Content-ID from the Part."
+ + e);
+ }
+ } else
+ return null;
+ }
+
+ /**
+ * @return This will return the next available MIME part in the stream.
+ * @throws OMException
+ * if Stream ends while reading the next part...
+ */
+ private Part getPart() throws OMException {
+ // endOfStreamReached will be set to true if the message ended in MIME
+ // Style having "--" suffix with the last mime boundary
+ if (endOfStreamReached)
+ throw new OMException(
+ "Referenced MIME part not found.End of Stream reached.");
+
+ Part part = null;
+
+ try {
+ if (fileCacheEnable) {
+ try {
+ MIMEBodyPartInputStream partStream;
+ byte[] buffer = new byte[fileStorageThreshold];
+ partStream = new MIMEBodyPartInputStream(pushbackInStream,
+ boundary, this);
+ int count = 0;
+ int value;
+ // Make sure not to modify this to a Short Circuit "&". If
+ // removed a byte will be lost
+ while (count != fileStorageThreshold
+ && (!partStream.getBoundaryStatus())) {
+ value = partStream.read();
+ buffer[count] = (byte) value;
+ count++;
+ }
+ if (count == fileStorageThreshold) {
+ PushbackFilePartInputStream filePartStream = new PushbackFilePartInputStream(
+ partStream, buffer);
+ part = new PartOnFile(filePartStream, attachmentRepoDir);
+ } else {
+ ByteArrayInputStream byteArrayInStream = new ByteArrayInputStream(
+ buffer,0,count-1);
+ part = new PartOnMemory(byteArrayInStream);
+ }
+ } catch (Exception e) {
+ throw new OMException("Error creating temporary File.", e);
+ }
+ } else {
+ MIMEBodyPartInputStream partStream;
+ partStream = new MIMEBodyPartInputStream(pushbackInStream,
+ boundary, this);
+ part = new PartOnMemory(partStream);
+ }
+ // This will take care if stream ended without having MIME
+ // message terminator
+ if (part.getSize() <= 0) {
+ throw new OMException(
+ "Referenced MIME part not found.End of Stream reached.");
+ }
+ } catch (MessagingException e) {
+ throw new OMException(e);
+ }
+ partIndex++;
+ return part;
+ }
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/attachments/Part.java b/src/org/apache/ws/commons/attachments/Part.java
new file mode 100644
index 0000000..4987608
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/Part.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import javax.activation.DataHandler;
+import javax.mail.MessagingException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+
+public interface Part{
+
+
+ public int getSize() throws MessagingException ;
+
+ public String getContentType() throws MessagingException;
+
+ public String getContentID() throws MessagingException;
+
+ public String getFileName() throws MessagingException;
+
+ public InputStream getInputStream() throws IOException, MessagingException ;
+
+ public DataHandler getDataHandler() throws MessagingException ;
+
+ public String getHeader(String arg0) throws MessagingException ;
+
+ public Enumeration getAllHeaders() throws MessagingException ;
+
+}
diff --git a/src/org/apache/ws/commons/attachments/PartOnFile.java b/src/org/apache/ws/commons/attachments/PartOnFile.java
new file mode 100644
index 0000000..7f55df2
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/PartOnFile.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import org.apache.ws.commons.om.OMException;
+
+import javax.activation.DataHandler;
+import javax.activation.FileDataSource;
+import javax.mail.MessagingException;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Enumeration;
+import java.util.HashMap;
+
+public class PartOnFile implements Part {
+
+ File cacheFile;
+
+ Part bodyPart;
+
+ String contentType;
+
+ String contentID;
+
+ HashMap headers;
+
+ public PartOnFile(PushbackFilePartInputStream inStream, String repoDir) {
+ super();
+
+ headers = new HashMap();
+
+ if (repoDir == null) {
+ repoDir = ".";
+ }
+ try {
+ cacheFile = File.createTempFile("Axis2", ".att",
+ (repoDir == null) ? null : new File(repoDir));
+
+ FileOutputStream fileOutStream = new FileOutputStream(cacheFile);
+ int value;
+ value = parseTheHeaders(inStream);
+ fileOutStream.write(value);
+ while (!inStream.getBoundaryStatus()) {
+ value = inStream.read();
+ if (!inStream.getBoundaryStatus()) {
+ fileOutStream.write(value);
+ }
+
+ }
+
+ fileOutStream.flush();
+ fileOutStream.close();
+ } catch (IOException e) {
+ throw new OMException("Error creating temporary File.", e);
+ }
+ }
+
+ private int parseTheHeaders(InputStream inStream) throws IOException {
+ int value;
+ boolean readingHeaders = true;
+ StringBuffer header = new StringBuffer();
+ while (readingHeaders & (value = inStream.read()) != -1) {
+ if (value == 13) {
+ if ((value = inStream.read()) == 10) {
+ if ((value = inStream.read()) == 13) {
+ if ((value = inStream.read()) == 10) {
+ putToMap(header);
+ readingHeaders = false;
+ }
+ } else {
+ putToMap(header);
+ header = new StringBuffer();
+ header.append((char) value);
+ }
+ } else {
+ header.append(13);
+ header.append(value);
+ }
+ } else {
+ header.append((char) value);
+ }
+ }
+ return value;
+ }
+
+ private void putToMap(StringBuffer header) {
+ String headerString = header.toString();
+ int delimiter = headerString.indexOf(":");
+ headers.put(headerString.substring(0, delimiter).trim(), headerString
+ .substring(delimiter + 1, headerString.length()).trim());
+ }
+
+ public String getContentID() {
+ String cID = (String) headers.get("Content-ID");
+ if (cID == null) {
+ cID = (String) headers.get("Content-Id");
+ if (cID == null) {
+ cID = (String) headers.get("Content-id");
+ if (cID == null) {
+ cID = (String) headers.get("content-id");
+ }
+ }
+
+ }
+ return cID;
+ }
+
+ public int getSize() throws MessagingException {
+ return (int) cacheFile.length();
+ }
+
+ public int getLineCount() throws MessagingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public String getDescription() throws MessagingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public void setDescription(String arg0) throws MessagingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public String getFileName() throws MessagingException {
+ return cacheFile.getAbsolutePath();
+ }
+
+ public InputStream getInputStream() throws IOException, MessagingException {
+ return new FileInputStream(cacheFile);
+ }
+
+ public DataHandler getDataHandler() throws MessagingException {
+ return new DataHandler(new FileDataSource(cacheFile));
+ }
+
+ public Object getContent() throws IOException, MessagingException {
+ return getDataHandler().getContent();
+ }
+
+ public void writeTo(OutputStream outStream) throws IOException,
+ MessagingException {
+ getDataHandler().writeTo(outStream);
+ }
+
+ public String getHeader(String arg0) throws MessagingException {
+ String header;
+ header = (String) headers.get(arg0);
+ return header;
+ }
+
+ public Enumeration getAllHeaders() throws MessagingException {
+ return null;
+ }
+
+ public String getContentType() throws MessagingException {
+ String cType = (String) headers.get("Content-Type");
+ if (cType == null) {
+ cType = (String) headers.get("Content-type");
+ if (cType == null) {
+ cType = (String) headers.get("content-type");
+ }
+ }
+ return cType;
+ }
+
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/attachments/PartOnMemory.java b/src/org/apache/ws/commons/attachments/PartOnMemory.java
new file mode 100644
index 0000000..c8e68b1
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/PartOnMemory.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import javax.activation.DataHandler;
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeBodyPart;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+
+public class PartOnMemory implements Part{
+
+ MimeBodyPart part;
+ public PartOnMemory(InputStream partInStream) throws MessagingException
+ {
+ part = new MimeBodyPart(partInStream);
+ }
+
+ public int getSize() throws MessagingException {
+ return part.getSize();
+ }
+
+ public String getContentType() throws MessagingException {
+ return part.getContentType();
+ }
+
+ public String getFileName() throws MessagingException {
+ return part.getFileName();
+ }
+
+ public InputStream getInputStream() throws IOException, MessagingException {
+ return part.getInputStream();
+ }
+
+ public DataHandler getDataHandler() throws MessagingException {
+ return part.getDataHandler();
+ }
+
+ public String getHeader(String arg0) throws MessagingException {
+ return part.getHeader(arg0)[0];
+ }
+
+ public Enumeration getAllHeaders() throws MessagingException {
+ return part.getAllHeaders();
+ }
+
+
+ public String getContentID() throws MessagingException {
+ return part.getContentID();
+ }
+}
diff --git a/src/org/apache/ws/commons/attachments/PushbackFilePartInputStream.java b/src/org/apache/ws/commons/attachments/PushbackFilePartInputStream.java
new file mode 100644
index 0000000..b78061f
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/PushbackFilePartInputStream.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class PushbackFilePartInputStream extends InputStream {
+
+ MIMEBodyPartInputStream inStream;
+
+ byte[] buffer;
+
+ int count;
+
+ /**
+ * @param inStream
+ * @param buffer
+ */
+ public PushbackFilePartInputStream(MIMEBodyPartInputStream inStream,
+ byte[] buffer) {
+ super();
+ this.inStream = inStream;
+ this.buffer = buffer;
+ count = buffer.length;
+ }
+
+ public int read() throws IOException {
+ int data;
+ if (count > 0) {
+ data = buffer[buffer.length - count];
+ count--;
+ } else {
+ data = inStream.read();
+ }
+ return data;
+ }
+
+ public boolean getBoundaryStatus()
+ {
+ return inStream.getBoundaryStatus();
+ }
+
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/attachments/utils/IOUtils.java b/src/org/apache/ws/commons/attachments/utils/IOUtils.java
new file mode 100644
index 0000000..1f01bee
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/utils/IOUtils.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments.utils;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * Utility class containing IO helper methods
+ */
+public class IOUtils {
+ private IOUtils() {
+ }
+
+ /**
+ * Reads into a byte array. Ensures that the full buffer is read.
+ * Helper method, just calls <tt>readFully(in, b, 0, b.length)</tt>
+ *
+ * @see #readFully(java.io.InputStream, byte[], int, int)
+ */
+ public static int readFully(InputStream in, byte[] b)
+ throws IOException {
+ return readFully(in, b, 0, b.length);
+ }
+
+ /**
+ * Same as the normal <tt>in.read(b, off, len)</tt>, but tries to ensure that
+ * the entire len number of bytes is read.
+ *
+ * @return Returns the number of bytes read, or -1 if the end of file is
+ * reached before any bytes are read
+ */
+ public static int readFully(InputStream in, byte[] b, int off, int len)
+ throws IOException {
+ int total = 0;
+ for (; ;) {
+ int got = in.read(b, off + total, len - total);
+ if (got < 0) {
+ return (total == 0) ? -1 : total;
+ } else {
+ total += got;
+ if (total == len)
+ return total;
+ }
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/attachments/utils/ImageDataSource.java b/src/org/apache/ws/commons/attachments/utils/ImageDataSource.java
new file mode 100644
index 0000000..506d804
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/utils/ImageDataSource.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments.utils;
+
+import javax.activation.DataSource;
+import java.awt.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class ImageDataSource implements DataSource {
+
+ public static final String CONTENT_TYPE = "image/jpeg";
+
+ private final String name;
+
+ private final String contentType;
+
+ private byte[] data;
+
+ private ByteArrayOutputStream os;
+
+ public ImageDataSource(String name, Image data) throws Exception {
+ this(name, CONTENT_TYPE, data);
+ } // ctor
+
+ public ImageDataSource(String name, String contentType, Image data) throws Exception {
+ this.name = name;
+ this.contentType = contentType == null ? CONTENT_TYPE : contentType;
+ os = new ByteArrayOutputStream();
+ try {
+ if (data != null) {
+ new ImageIO().saveImage(this.contentType, data, os);
+ }
+ } catch (Exception e) {
+ throw e;
+ }
+ }
+
+ public String getName() {
+ return name;
+ } // getName
+
+ public String getContentType() {
+ return contentType;
+ } // getOptimizedContentType
+
+ public InputStream getInputStream() throws IOException {
+ if (os.size() != 0) {
+ data = os.toByteArray();
+ os.reset();
+ }
+ return new ByteArrayInputStream(data == null ? new byte[0] : data);
+ } // getInputStream
+
+ public OutputStream getOutputStream() throws IOException {
+ if (os.size() != 0) {
+ data = os.toByteArray();
+ os.reset();
+ }
+ return os;
+ } // getOutputStream
+} // class ImageDataSource
diff --git a/src/org/apache/ws/commons/attachments/utils/ImageIO.java b/src/org/apache/ws/commons/attachments/utils/ImageIO.java
new file mode 100644
index 0000000..d17d707
--- /dev/null
+++ b/src/org/apache/ws/commons/attachments/utils/ImageIO.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments.utils;
+
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageWriter;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Iterator;
+
+/**
+ * JDK1.4 based Image I/O
+ */
+public class ImageIO extends Component {
+
+ private static final long serialVersionUID = 4697911685739683266L;
+
+ /**
+ * Saves an image.
+ *
+ * @param mimeType the mime-type of the format to save the image
+ * @param image the image to save
+ * @param os the stream to write to
+ * @throws Exception if an error prevents image encoding
+ */
+ public void saveImage(String mimeType, Image image, OutputStream os)
+ throws Exception {
+
+ ImageWriter writer = null;
+ Iterator iter = javax.imageio.ImageIO.getImageWritersByMIMEType(mimeType);
+ if (iter.hasNext()) {
+ writer = (ImageWriter) iter.next();
+ }
+ writer.setOutput(javax.imageio.ImageIO.createImageOutputStream(os));
+ BufferedImage rendImage = null;
+ if (image instanceof BufferedImage) {
+ rendImage = (BufferedImage) image;
+ } else {
+ MediaTracker tracker = new MediaTracker(this);
+ tracker.addImage(image, 0);
+ tracker.waitForAll();
+ rendImage = new BufferedImage(image.getWidth(null), image.getHeight(null), 1);
+ Graphics g = rendImage.createGraphics();
+ g.drawImage(image, 0, 0, null);
+ }
+ writer.write(new IIOImage(rendImage, null, null));
+ writer.dispose();
+ } // saveImage
+
+ /**
+ * Loads an Image.
+ *
+ * @param in the stream to load the image
+ * @return the Image
+ */
+ public Image loadImage(InputStream in) throws Exception {
+ return javax.imageio.ImageIO.read(in);
+ } // loadImage
+}
+
diff --git a/src/org/apache/ws/commons/om/FactoryFinder.java b/src/org/apache/ws/commons/om/FactoryFinder.java
new file mode 100644
index 0000000..9578864
--- /dev/null
+++ b/src/org/apache/ws/commons/om/FactoryFinder.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPFactory;
+
+
+/**
+ * Class FactoryFinder
+ */
+class FactoryFinder {
+ private static final String DEFAULT_OM_FACTORY_CLASS_NAME =
+ "org.apache.ws.commons.om.impl.llom.factory.OMLinkedListImplFactory";
+ private static final String DEFAULT_SOAP11_FACTORY_CLASS_NAME =
+ "org.apache.ws.commons.soap.impl.llom.soap11.SOAP11Factory";
+ private static final String DEFAULT_SOAP12_FACTORY_CLASS_NAME =
+ "org.apache.ws.commons.soap.impl.llom.soap12.SOAP12Factory";
+
+ /**
+ * @param loader
+ * @return
+ * @throws OMFactoryException
+ */
+
+
+ private static Object findFactory(ClassLoader loader,
+ String factoryClass,
+ String systemPropertyName)
+ throws OMFactoryException {
+
+ String factoryClassName = factoryClass;
+
+ //first look for a java system property
+ if (systemPropertyName != null &&
+ System.getProperty(systemPropertyName) != null) {
+ factoryClassName = System.getProperty(systemPropertyName);
+ }
+
+ Object factory;
+ try {
+ if (loader == null) {
+ factory = Class.forName(factoryClassName).newInstance();
+ } else {
+ factory = loader.loadClass(factoryClassName).newInstance();
+ }
+ } catch (Exception e) {
+ throw new OMFactoryException(e);
+ }
+ return factory;
+ }
+
+ /**
+ * The searching for the factory class happens in the following order
+ * 1. look for a system property called <b>soap11.factory</b>. this can be set by
+ * passing the -Dsoap11.factory="classname"
+ * 2. Pick the default factory class.
+ * it is the class hardcoded at the constant DEFAULT_SOAP11_FACTORY_CLASS_NAME
+ *
+ * @param loader
+ * @return
+ * @throws OMFactoryException
+ */
+ public static SOAPFactory findSOAP11Factory(ClassLoader loader)
+ throws OMFactoryException {
+ return (SOAPFactory) findFactory(loader,
+ DEFAULT_SOAP11_FACTORY_CLASS_NAME,
+ OMAbstractFactory.SOAP11_FACTORY_NAME_PROPERTY);
+ }
+
+ /**
+ * The searching for the factory class happens in the following order
+ * 1. look for a system property called <b>soap12.factory</b>. this can be set by
+ * passing the -Dsoap12.factory="classname"
+ * 2. Pick the default factory class.
+ * it is the class hardcoded at the constant DEFAULT_SOAP12_FACTORY_CLASS_NAME
+ *
+ * @param loader
+ * @return
+ * @throws OMFactoryException
+ */
+ public static SOAPFactory findSOAP12Factory(ClassLoader loader)
+ throws OMFactoryException {
+ return (SOAPFactory) findFactory(loader,
+ DEFAULT_SOAP12_FACTORY_CLASS_NAME,
+ OMAbstractFactory.SOAP12_FACTORY_NAME_PROPERTY);
+ }
+
+ /**
+ * The searching for the factory class happens in the following order
+ * 1. look for a system property called <b>om.factory</b>. this can be set by
+ * passing the -Dom.factory="classname"
+ * 2. Pick the default factory class.
+ * it is the class hardcoded at the constant DEFAULT_OM_FACTORY_CLASS_NAME
+ *
+ * @param loader
+ * @return
+ * @throws OMFactoryException
+ */
+ public static OMFactory findOMFactory(ClassLoader loader)
+ throws OMFactoryException {
+ return (OMFactory) findFactory(loader,
+ DEFAULT_OM_FACTORY_CLASS_NAME,
+ OMAbstractFactory.OM_FACTORY_NAME_PROPERTY);
+ }
+
+ /**
+ *
+ * @param classLoader
+ * @param soapFactory
+ * @return The SOAPFactory
+ */
+ public static SOAPFactory findSOAPFactory(final ClassLoader classLoader,
+ final String soapFactory) {
+ return (SOAPFactory) findFactory(classLoader,
+ soapFactory,
+ null);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/OMAbstractFactory.java b/src/org/apache/ws/commons/om/OMAbstractFactory.java
new file mode 100644
index 0000000..c9a0925
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMAbstractFactory.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.impl.llom.factory.SOAPLinkedListImplFactory;
+
+public class OMAbstractFactory {
+ public static final String OM_FACTORY_NAME_PROPERTY = "om.factory";
+ public static final String SOAP11_FACTORY_NAME_PROPERTY = "soap11.factory";
+ public static final String SOAP12_FACTORY_NAME_PROPERTY = "soap12.factory";
+ public static final String SOAP_FACTORY_NAME_PROPERTY = "soap.factory";
+
+ /**
+ * Picks up the default factory implementation from the classpath.
+ *
+ * @return Returns OMFactory.
+ */
+ public static OMFactory getOMFactory() {
+ return FactoryFinder.findOMFactory(null);
+ }
+
+ /**
+ * If user needs to provide his own factory implementation, provide the
+ * Class Loader here.
+ *
+ * @param classLoader
+ * @return Returns OMFactory.
+ */
+ public static OMFactory getOMFactory(ClassLoader classLoader) {
+ return FactoryFinder.findOMFactory(classLoader);
+ }
+
+ /**
+ * Gets the <code>soapFactory</code> factory implementation from the classpath
+ *
+ * @param soapFactory Fully qualified SOAP 1.1 or SOAP 1.2 Factory implementation class name
+ * @return Returns the SOAP 1.1 or 1.2 Factory implementation instance corresponding to <code>soapFactory</code>
+ */
+ public static SOAPFactory getSOAPFactory(String soapFactory) {
+ return FactoryFinder.findSOAPFactory(null, soapFactory);
+ }
+
+ /**
+ * Gets the <code>soapFactory</code> factory implementation using the provided
+ * <code>classLoader</code>
+ *
+ * @param classLoader
+ * @param soapFactory Fully qualified SOAP 1.1 or SOAP 1.2 Factory implementation class name
+ * @return Returns the SOAP 1.1 or 1.2 Factory implementation instance corresponding to <code>soapFactory</code>
+ */
+ public static SOAPFactory getSOAPFactory(ClassLoader classLoader, String soapFactory) {
+ return FactoryFinder.findSOAPFactory(classLoader, soapFactory);
+ }
+
+ /**
+ * Gets the default factory implementation from the classpath.
+ *
+ * @return Returns SOAPFactory.
+ */
+ public static SOAPFactory getSOAP11Factory() {
+ return FactoryFinder.findSOAP11Factory(null);
+ }
+
+ /**
+ * If user needs to provide his own factory implementation, provide the
+ * Class Loader here.
+ *
+ * @param classLoader
+ * @return Returns SOAPFactory.
+ */
+ public static SOAPFactory getSOAP11Factory(ClassLoader classLoader) {
+ return FactoryFinder.findSOAP11Factory(classLoader);
+ }
+
+ /**
+ * Gets the default factory implementation from the classpath.
+ *
+ * @return Returns SOAPFactory.
+ */
+ public static SOAPFactory getSOAP12Factory() {
+ return FactoryFinder.findSOAP12Factory(null);
+ }
+
+ /**
+ * If user needs to provide his own factory implementation, provide the
+ * Class Loader here.
+ *
+ * @param classLoader
+ * @return Returns SOAPFactory.
+ */
+ public static SOAPFactory getSOAP12Factory(ClassLoader classLoader) {
+ return FactoryFinder.findSOAP12Factory(classLoader);
+ }
+
+ /**
+ * WARNING - DO NOT USE THIS METHOD !!!!!.
+ * This method is used in the case where we do not know the correct SOAP version to be used.
+ * We can do some operation using the factory returned from this, without knowing the SOAP version.
+ * But most of the methods have not been implemented.
+ * We use this in the builder, where we want to first create the SOAP envelope to get the SOAP version.
+ * So this method is to solve the chicken and egg problem, we have. If you do not know the SOAP version to be used
+ * to process a particluar SOAP message you have recd, use this method to buid the SOAP envelope, and then extract the SOAP
+ * version from that envlope and switch to the proper factory using that.
+ */
+ public static SOAPFactory getDefaultSOAPFactory() {
+ return new SOAPLinkedListImplFactory();
+ }
+}
diff --git a/src/org/apache/ws/commons/om/OMAttribute.java b/src/org/apache/ws/commons/om/OMAttribute.java
new file mode 100644
index 0000000..66e03ca
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMAttribute.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Interface OMAttribute
+ */
+public interface OMAttribute {
+ /**
+ * @return Returns localName.
+ */
+ public String getLocalName();
+
+ /**
+ * @param localName
+ */
+ public void setLocalName(String localName);
+
+ /**
+ * @return Returns String.
+ */
+ public String getAttributeValue();
+
+ /**
+ * @param value
+ */
+ public void setAttributeValue(String value);
+
+ /**
+ * @param omNamespace
+ */
+ public void setOMNamespace(OMNamespace omNamespace);
+
+ /**
+ * @return Returns OMNamespace.
+ */
+ public OMNamespace getNamespace();
+
+ /**
+ * @return Returns javax.xml.namespace.QName
+ */
+ public QName getQName();
+}
diff --git a/src/org/apache/ws/commons/om/OMComment.java b/src/org/apache/ws/commons/om/OMComment.java
new file mode 100644
index 0000000..c8e68f4
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMComment.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMComment
+ */
+public interface OMComment extends OMNode {
+ /**
+ * Returns the value of this comment as defined by XPath 1.0.
+ * @return Returns String.
+ */
+ public String getValue();
+
+ /**
+ * Sets the content of this comment to the specified string.
+ * @param text
+ */
+ public void setValue(String text);
+}
diff --git a/src/org/apache/ws/commons/om/OMConstants.java b/src/org/apache/ws/commons/om/OMConstants.java
new file mode 100644
index 0000000..8b812f5
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMConstants.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMConstants
+ */
+public interface OMConstants {
+
+
+ // OMBuilder constants
+ /**
+ * Field PUSH_TYPE_BUILDER
+ */
+ public static final short PUSH_TYPE_BUILDER = 0;
+
+ /**
+ * Field PULL_TYPE_BUILDER
+ */
+ public static final short PULL_TYPE_BUILDER = 1;
+
+ /**
+ * Field ARRAY_ITEM_NSURI
+ */
+ public static final String ARRAY_ITEM_NSURI =
+ "http://axis.apache.org/encoding/Arrays";
+
+ /**
+ * Field ARRAY_ITEM_LOCALNAME
+ */
+ public static final String ARRAY_ITEM_LOCALNAME = "item";
+
+ /**
+ * Field ARRAY_ITEM_NS_PREFIX
+ */
+ public static final String ARRAY_ITEM_NS_PREFIX = "arrays";
+
+ /**
+ * Field ARRAY_ITEM_QNAME
+ */
+ public static final String ARRAY_ITEM_QNAME =
+ OMConstants.ARRAY_ITEM_NS_PREFIX + ':'
+ + OMConstants.ARRAY_ITEM_LOCALNAME;
+
+ /**
+ * Field DEFAULT_CHAR_SET_ENCODING specifies the default
+ * character encoding scheme to be used
+ */
+ public static final String DEFAULT_CHAR_SET_ENCODING = "utf-8";
+ public static final String DEFAULT_XML_VERSION = "1.0";
+
+
+ public static final String XMLNS_URI =
+ "http://www.w3.org/XML/1998/namespace";
+
+ public static final String XMLNS_NS_URI = "http://www.w3.org/2000/xmlns/";
+ public final static String XMLNS_NS_PREFIX = "xmlns";
+
+ public static final String XMLNS_PREFIX =
+ "xml";
+}
diff --git a/src/org/apache/ws/commons/om/OMContainer.java b/src/org/apache/ws/commons/om/OMContainer.java
new file mode 100644
index 0000000..09972d0
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMContainer.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+/**
+ * Captures the operations related to containment shared by both a document and an element.
+ *
+ * <p>Exposes the ability to add, find, and iterate over the children of a document or
+ * element.</p>
+ */
+public interface OMContainer {
+
+ /**
+ * Adds the given node as the last child. One must preserve the order of children,
+ * in this operation.
+ * Tip : appending the new child is preferred.
+ *
+ * @param omNode
+ */
+ public void addChild(OMNode omNode);
+
+ /**
+ * Returns an iterator for child nodes matching the criteria indicated by the given QName.
+ *
+ * <p>This function searches in three ways:
+ * <ul>
+ * <li>Exact match - Both parts of the passed QName are non-null. Only children with the
+ * same namespace and local name will be returned.
+ * </li>
+ * <li>Namespace match - The local name of the passed QName is null. All children matching the
+ * namespace will be returned by the iterator.
+ * </li>
+ * <li>Local name match - The namespace of the passed QName is null. All children with the
+ * matching local name will be returned by the iterator.
+ * </li>
+ * </ul>
+ *
+ * <p>
+ * <b>Example:</b> <code>header.getChildrenWithName( new QName(ADDRESSING_NAMESPACE, null));</code>
+ * will return all of the "addressing" headers.
+ * </p>
+ *
+ * @param elementQName The QName specifying namespace and local name to match.
+ * @return Returns an iterator of {@link OMElement} items that match the given QName appropriately.
+ */
+ public Iterator getChildrenWithName(QName elementQName);
+
+ /**
+ * Returns the first child in document order that matches the given QName criteria.
+ *
+ * <p>The QName filter is applied as in the function {@link #getChildrenWithName}.</p>
+ *
+ * @param elementQName The QName to use for matching.
+ *
+ * @return Returns the first element in document order that matches the <tt>elementQName</tt> criteria.
+ *
+ * @see #getChildrenWithName
+ *
+ * @throws OMException Could indirectly trigger building of child nodes.
+ */
+ public OMElement getFirstChildWithName(QName elementQName) throws OMException;
+
+ /**
+ * Returns an iterator for the children of the container.
+ *
+ * @return Returns a {@link Iterator} of children, all of which implement {@link OMNode}.
+ *
+ * @see #getFirstChildWithName
+ * @see #getChildrenWithName
+ */
+ public Iterator getChildren();
+
+ /**
+ * Gets the first child.
+ *
+ * @return Returns the first child. May return null if the container has no children.
+ */
+ public OMNode getFirstOMChild();
+
+ public boolean isComplete();
+
+ public void buildNext();
+}
diff --git a/src/org/apache/ws/commons/om/OMDocType.java b/src/org/apache/ws/commons/om/OMDocType.java
new file mode 100644
index 0000000..31fd3c6
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMDocType.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMDocType
+ */
+public interface OMDocType extends OMNode {
+ /**
+ * Returns the value of this DocType.
+ * @return Returns String.
+ */
+ public String getValue();
+
+ /**
+ * Sets the content of this DocType to the specified string.
+ * @param text
+ */
+ public void setValue(String text);
+}
diff --git a/src/org/apache/ws/commons/om/OMDocument.java b/src/org/apache/ws/commons/om/OMDocument.java
new file mode 100644
index 0000000..7242506
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMDocument.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.OutputStream;
+
+
+public interface OMDocument extends OMContainer {
+
+ /**
+ * Field XML_10 XML Version 1.0
+ */
+ public final static String XML_10 = "1.0";
+
+ /**
+ * Field XML_11 XML Version 1.1
+ */
+ public final static String XML_11 = "1.1";
+
+ /**
+ * Returns the document element.
+ * @return Returns OMElement.
+ */
+ public OMElement getOMDocumentElement();
+
+ /**
+ * Sets the document element of the XML document.
+ * @param rootElement
+ */
+ public void setOMDocumentElement(OMElement rootElement);
+
+ /**
+ * Returns the XML version.
+ * @return Returns String.
+ */
+ public String getXMLVersion();
+
+ /**
+ * Sets the XML version.
+ * @see org.apache.ws.commons.om.impl.llom.OMDocumentImpl#XML_10 XML 1.0
+ * @see org.apache.ws.commons.om.impl.llom.OMDocumentImpl#XML_11 XML 1.1
+ * @param version
+ */
+ public void setXMLVersion(String version);
+
+ /**
+ * Returns the character set encoding scheme.
+ * @return Returns String.
+ */
+ public String getCharsetEncoding();
+
+ /**
+ * Sets the character set encoding scheme to be used.
+ * @param charsetEncoding
+ */
+ public void setCharsetEncoding(String charsetEncoding);
+
+ /**
+ * XML standalone value.
+ * This will be yes, no or null (if not available)
+ * @return Returns boolean.
+ */
+ public String isStandalone();
+ public void setStandalone(String isStandalone);
+
+ /**
+ * Serializes the OMDocument.
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output, OMOutputFormat format) throws XMLStreamException;
+
+ /**
+ * Builds the OM node/tree and then serializes the document.
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException;
+
+ /**
+ * Serializes the OMDocument.
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output) throws XMLStreamException;
+
+ /**
+ * Serializes the document with cache on.
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output) throws XMLStreamException;
+}
diff --git a/src/org/apache/ws/commons/om/OMElement.java b/src/org/apache/ws/commons/om/OMElement.java
new file mode 100644
index 0000000..9c72b21
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMElement.java
@@ -0,0 +1,299 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.util.Iterator;
+
+/**
+ * A particular kind of node that represents an element infoset information item.
+ * <p/>
+ * <p>An element has a collection of children, attributes, and namespaces.</p>
+ * <p>In contrast with DOM, this interface exposes namespaces separately from the
+ * attributes.</p>
+ */
+public interface OMElement extends OMNode, OMContainer {
+
+ /**
+ * Returns a filtered list of children - just the elements.
+ *
+ * @return Returns an iterator over the child elements.
+ * @see #getChildren()
+ * @see #getChildrenWithName(javax.xml.namespace.QName)
+ */
+ public Iterator getChildElements();
+
+ /**
+ * Creates a namespace in the current element scope.
+ *
+ * @param uri The namespace to declare in the current scope. The
+ * caller is expected to ensure that the URI is a valid namespace name.
+ * @param prefix The prefix to associate with the given namespace.
+ * The caller is expected to ensure that this is a valid XML prefix.
+ * @return Returns the created namespace information item.
+ * @see #declareNamespace(OMNamespace)
+ * @see #findNamespace(String, String)
+ * @see #getAllDeclaredNamespaces()
+ */
+ public OMNamespace declareNamespace(String uri, String prefix);
+
+ /**
+ * Declares a namespace with the element as its scope.
+ *
+ * @param namespace The namespace to declare
+ * @return Returns the namespace parameter passed.
+ * @see #declareNamespace(String, String)
+ * @see #findNamespace(String, String)
+ * @see #getAllDeclaredNamespaces()
+ */
+ public OMNamespace declareNamespace(OMNamespace namespace);
+
+ /**
+ * Finds a namespace with the given uri and prefix, in the scope of the hierarchy.
+ * <p/>
+ * <p>Searches from the current element and goes up the hiararchy until a match is found.
+ * If no match is found, returns <tt>null</tt>.</p>
+ * <p/>
+ * <p>Either <tt>prefix</tt> or <tt>uri</tt> should be null. Results are undefined
+ * if both are specified.</p>
+ *
+ * @param uri The namespace to look for. If this is specified, <tt>prefix</tt> should be null.
+ * @param prefix The prefix to look for. If this is specified, <tt>uri</tt> should be null.
+ * @return Returns the matching namespace declaration, or <tt>null</tt> if none was found.
+ * @see #declareNamespace(String, String)
+ * @see #declareNamespace(OMNamespace)
+ * @see #getAllDeclaredNamespaces()
+ */
+ public OMNamespace findNamespace(String uri, String prefix);
+
+ /**
+ * Checks for a namespace in the context of this element with the given prefix and
+ * returns the relevant namespace object, if available. If not available, returns null.
+ *
+ * @param prefix
+ */
+ public OMNamespace findNamespaceURI(String prefix);
+
+ /**
+ * Returns an iterator for all of the namespaces declared on this element.
+ * <p/>
+ * <p>If you're interested in all namespaces in scope, you need to call this function
+ * for all parent elements as well. Note that the iterator may be invalidated by
+ * any call to either <tt>declareNamespace</tt> function.
+ * </p>
+ *
+ * @return Returns an iterator over the {@link OMNamespace} items declared on the current element.
+ * @see #findNamespace(String, String)
+ * @see #declareNamespace(String, String)
+ * @see #declareNamespace(OMNamespace)
+ */
+ public Iterator getAllDeclaredNamespaces() throws OMException;
+
+ /**
+ * Returns a list of OMAttributes.
+ *
+ * <p>Note that the iterator returned by this function will be invalidated by
+ * any <tt>addAttribute</tt> call.
+ * </p>
+ *
+ * @return Returns an {@link Iterator} of {@link OMAttribute} items associated with the element.
+ * @see #getAttribute
+ * @see #addAttribute(OMAttribute)
+ * @see #addAttribute(String, String, OMNamespace)
+ */
+ public Iterator getAllAttributes();
+
+ /**
+ * Returns a named attribute if present.
+ *
+ * @param qname the qualified name to search for
+ * @return Returns an OMAttribute with the given name if found, or null
+ */
+ public OMAttribute getAttribute(QName qname);
+
+ /**
+ * Returns a named attribute's value, if present.
+ *
+ * @param qname the qualified name to search for
+ * @return Returns a String containing the attribute value, or null
+ */
+ public String getAttributeValue(QName qname);
+
+ /**
+ * Adds an attribute to this element.
+ * <p/>
+ * <p>There is no order implied by added attributes.</p>
+ *
+ * @param attr The attribute to add.
+ * @return Returns the passed in attribute.
+ */
+ public OMAttribute addAttribute(OMAttribute attr);
+
+ /**
+ * Adds an attribute to the current element.
+ * <p/>
+ * <p>This function does not check to make sure that the given attribute value can be serialized directly
+ * as an XML value. The caller may, for example, pass a string with the character 0x01.
+ *
+ * @param attributeName The "local name" for the attribute.
+ * @param value The string value of the attribute.
+ * @param ns The namespace has to be one of the in scope namespace. i.e. the passed namespace
+ * must be declared in the parent element of this attribute or ancestors of the parent element of the attribute.
+ * @return Returns the added attribute.
+ */
+ public OMAttribute addAttribute(String attributeName, String value,
+ OMNamespace ns);
+
+ /**
+ * Method removeAttribute
+ *
+ * @param attr
+ */
+ public void removeAttribute(OMAttribute attr);
+
+ /**
+ * Method setBuilder.
+ *
+ * @param wrapper
+ */
+ public void setBuilder(OMXMLParserWrapper wrapper);
+
+ /**
+ * Returns the builder object.
+ *
+ * @return Returns the builder object used to construct the underlying XML infoset on the fly.
+ */
+ public OMXMLParserWrapper getBuilder();
+
+ /**
+ * Sets the first child.
+ *
+ * @param node
+ */
+ public void setFirstChild(OMNode node);
+
+ /**
+ * Returns the first child element of the element.
+ *
+ * @return Returns the first child element of the element, or <tt>null</tt> if none was found.
+ */
+
+ public OMElement getFirstElement();
+
+
+ /**
+ * Returns the pull parser that will generate the pull
+ * events relevant to THIS element.
+ * <p/>
+ * <p>Caching is on.</p>
+ *
+ * @return Returns an XMLStreamReader relative to this element.
+ */
+ public XMLStreamReader getXMLStreamReader();
+
+ /**
+ * Returns the pull parser that will generate the pull
+ * events relevant to THIS element.
+ * <p/>
+ * <p>Caching is off.</p>
+ *
+ * @return Returns an XMLStreamReader relative to this element, with no caching.
+ */
+ public XMLStreamReader getXMLStreamReaderWithoutCaching();
+
+ /**
+ * @param text
+ */
+ public void setText(String text);
+
+ /**
+ * Returns the non-empty text children as a String.
+ *
+ * @return Returns a String representing the concatenation of the child text nodes.
+ */
+ public String getText();
+
+ /**
+ * Returns the local name of the element.
+ *
+ * @return Returns the local name of the element.
+ */
+ public String getLocalName();
+
+ /**
+ * Method setLocalName
+ *
+ * @param localName
+ */
+ public void setLocalName(String localName);
+
+ /**
+ * @return Returns the OMNamespace object associated with this element
+ * @throws OMException
+ */
+ public OMNamespace getNamespace() throws OMException;
+
+ /**
+ * Sets the Namespace.
+ *
+ * @param namespace
+ */
+ public void setNamespace(OMNamespace namespace);
+
+ /**
+ * Gets the QName of this node.
+ *
+ * @return Returns the {@link QName} for the element.
+ */
+ public QName getQName();
+
+ /**
+ * This is a convenience method only. This will basically serialize the given OMElement
+ * to a String but will build the OMTree in the memory
+ */
+ public String toString();
+
+ /**
+ * This is a convenience method only. This basically serializes the given OMElement
+ * to a String but will NOT build the OMTree in the memory. So you are at your own risk of
+ * losing information.
+ */
+ public String toStringWithConsume() throws XMLStreamException;
+
+
+ /**
+ * Turns a prefix:local qname string into a proper QName, evaluating it in the OMElement context.
+ * Unprefixed qnames resolve to the local namespace.
+ *
+ * @param qname prefixed qname string to resolve
+ * @return Returns null for any failure to extract a qname.
+ */
+ QName resolveQName(String qname);
+
+ /**
+ * Clones this element. Since both elements are build compleletely, you will
+ * lose the differed building capability.
+ * @return Returns OMElement.
+ */
+ public OMElement cloneOMElement();
+
+
+ public void setLineNumber(int lineNumber);
+ public int getLineNumber();
+}
diff --git a/src/org/apache/ws/commons/om/OMException.java b/src/org/apache/ws/commons/om/OMException.java
new file mode 100644
index 0000000..c18d7ef
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMException.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Class OMException
+ */
+public class OMException extends RuntimeException {
+ /**
+ * Constructor OMException
+ */
+ public OMException() {
+ }
+
+ /**
+ * Constructor OMException
+ *
+ * @param message
+ */
+ public OMException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor OMException
+ *
+ * @param message
+ * @param cause
+ */
+ public OMException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Constructor OMException
+ *
+ * @param cause
+ */
+ public OMException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/OMFactory.java b/src/org/apache/ws/commons/om/OMFactory.java
new file mode 100644
index 0000000..ce35ffa
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMFactory.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Class OMFactory
+ */
+public interface OMFactory {
+
+ /**
+ * Creates a new OMDocument.
+ */
+ public OMDocument createOMDocument();
+ public OMDocument createOMDocument(OMXMLParserWrapper builder);
+
+
+ /**
+ * @param localName
+ * @param ns
+ */
+ public OMElement createOMElement(String localName, OMNamespace ns);
+ public OMElement createOMElement(String localName, OMNamespace ns, OMContainer parent) throws OMException;
+
+ /**
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ */
+ public OMElement createOMElement(String localName, OMNamespace ns,
+ OMContainer parent,
+ OMXMLParserWrapper builder);
+
+ /**
+ * This is almost the same as as createOMElement(localName,OMNamespace) method above.
+ * But some people may, for some reason, need to use the conventional method of putting a namespace.
+ * Or in other words people might not want to use the new OMNamespace.
+ * Well, this is for those people.
+ *
+ * @param localName
+ * @param namespaceURI
+ * @param namespacePrefix
+ * @return Returns the newly created OMElement.
+ */
+ public OMElement createOMElement(String localName,
+ String namespaceURI,
+ String namespacePrefix);
+
+ /**
+ * QName(localPart),
+ * QName(namespaceURI, localPart) - a prefix will be assigned to this
+ * QName(namespaceURI, localPart, prefix)
+ *
+ * @param qname
+ * @param parent
+ * @return Returns the new OMElement.
+ * @throws OMException
+ */
+ public OMElement createOMElement(QName qname, OMContainer parent)
+ throws OMException;
+
+ /**
+ * @param uri
+ * @param prefix
+ * @return Returns OMNameSpace.
+ */
+ public OMNamespace createOMNamespace(String uri, String prefix);
+
+ /**
+ * @param parent
+ * @param text
+ * @return Returns OMText.
+ */
+ public OMText createText(OMElement parent, String text);
+
+ /**
+ *
+ * @param parent
+ * @param text
+ * @param type - this should be either of XMLStreamConstants.CHARACTERS, XMLStreamConstants.CDATA,
+ * XMLStreamConstants.SPACE, XMLStreamConstants.ENTITY_REFERENCE
+ * @return Returns OMText.
+ */
+ public OMText createText(OMElement parent, String text, int type);
+
+ /**
+ * @param s
+ * @return Returns OMText.
+ */
+ public OMText createText(String s);
+
+ /**
+ *
+ * @param s
+ * @param type - OMText node can handle SPACE, CHARACTERS, CDATA and ENTITY REFERENCES. For Constants, use either
+ * XMLStreamConstants or constants found in OMNode.
+ * @return Returns OMText.
+ */
+ public OMText createText(String s, int type);
+
+ public OMText createText(String s, String mimeType, boolean optimize);
+
+ public OMText createText(Object dataHandler, boolean optimize);
+
+ public OMText createText(OMElement parent, String s, String mimeType,
+ boolean optimize);
+
+ public OMText createText(String contentID, OMElement parent,
+ OMXMLParserWrapper builder);
+
+ public OMAttribute createOMAttribute(String localName,
+ OMNamespace ns,
+ String value);
+
+ /**
+ * Creates DocType/DTD.
+ * @param parent
+ * @param content
+ * @return Returns doctype.
+ */
+ public OMDocType createOMDocType(OMContainer parent, String content);
+
+ /**
+ * Creates a PI.
+ * @param parent
+ * @param piTarget
+ * @param piData
+ * @return Returns OMProcessingInstruction.
+ */
+ public OMProcessingInstruction createOMProcessingInstruction(OMContainer parent, String piTarget, String piData);
+
+ /**
+ * Creates a comment.
+ * @param parent
+ * @param content
+ * @return Returns OMComment.
+ */
+ public OMComment createOMComment(OMContainer parent, String content);
+}
diff --git a/src/org/apache/ws/commons/om/OMFactoryException.java b/src/org/apache/ws/commons/om/OMFactoryException.java
new file mode 100644
index 0000000..d6136f8
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMFactoryException.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Class OMFactoryException
+ */
+public class OMFactoryException extends OMException {
+ /**
+ * Constructor OMFactoryException
+ */
+ public OMFactoryException() {
+ }
+
+ /**
+ * Constructor OMFactoryException
+ *
+ * @param message
+ */
+ public OMFactoryException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor OMFactoryException
+ *
+ * @param message
+ * @param cause
+ */
+ public OMFactoryException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Constructor OMFactoryException
+ *
+ * @param cause
+ */
+ public OMFactoryException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/OMNamespace.java b/src/org/apache/ws/commons/om/OMNamespace.java
new file mode 100644
index 0000000..ea3b909
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMNamespace.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMNamespace
+ */
+public interface OMNamespace {
+ /**
+ * Method equals.
+ *
+ * @param uri
+ * @param prefix
+ * @return Returns boolean.
+ */
+ public boolean equals(String uri, String prefix);
+
+ /**
+ * Method getPrefix.
+ *
+ * @return Returns String.
+ */
+ public String getPrefix();
+
+ /**
+ * Method getName.
+ *
+ * @return Returns String.
+ */
+ public String getName();
+}
diff --git a/src/org/apache/ws/commons/om/OMNode.java b/src/org/apache/ws/commons/om/OMNode.java
new file mode 100644
index 0000000..5dfbff6
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMNode.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.OutputStream;
+import java.io.Writer;
+
+/**
+ * Defines the base interface used by most of the XML object model within Axis.
+ *
+ * <p>This tree model for XML captures the idea of deferring the construction of child nodes
+ * until they are needed. The <code>isComplete</code> function identifies whether or not
+ * a particular node has been fully parsed. A node may not be fully parsed, for example, if
+ * all of the children of an element have not yet been parsed.</p>
+ *
+ * <p>In comparison to DOM, in this model, you will not find document fragments, or entities.
+ * In addition, while {@link OMDocument} and {@link OMAttribute} exist, neither is an extension
+ * of <code>OMNode</code>.
+ * </p>
+ */
+public interface OMNode {
+ /**
+ * The node is an <code>Element</code>.
+ *
+ * @see #getType()
+ */
+ public static final short ELEMENT_NODE = 1;
+
+ /**
+ * The node is a <code>Text</code> node.
+ *
+ * @see #getType()
+ */
+ public static final short TEXT_NODE = XMLStreamConstants.CHARACTERS;
+
+ /**
+ * The node is a <code>CDATASection</code>.
+ *
+ * @see #getType()
+ */
+ public static final short CDATA_SECTION_NODE = XMLStreamConstants.CDATA;
+
+ /**
+ * The node is a <code>Comment</code>.
+ *
+ * @see #getType()
+ */
+ public static final short COMMENT_NODE = XMLStreamConstants.COMMENT;
+
+ /**
+ * This node is a <code>DTD</code>.
+ *
+ * @see #getType()
+ */
+ public static final short DTD_NODE = XMLStreamConstants.DTD;
+
+ /**
+ * This node is a <code>ProcessingInstruction</code>.
+ *
+ * @see #getType()
+ */
+ public static final short PI_NODE = XMLStreamConstants.PROCESSING_INSTRUCTION;
+
+ /**
+ * This node is an <code>Entity Reference</code>.
+ *
+ * @see #getType()
+ */
+ public static final short ENTITY_REFERENCE_NODE = XMLStreamConstants.ENTITY_REFERENCE;
+
+ /**
+ * This node is an <code>Entity Reference</code>.
+ *
+ * @see #getType()
+ */
+ public static final short SPACE_NODE = XMLStreamConstants.SPACE;
+
+ /**
+ * Returns the parent containing node.
+ *
+ * <p>Returns the parent container, which may be either an {@link OMDocument} or {@link OMElement}.
+ *
+ * @return The {@link OMContainer} of the node.
+ */
+ public OMContainer getParent();
+
+ /**
+ * Returns the next sibling in document order.
+ *
+ * @return Returns the next sibling in document order.
+ */
+ public OMNode getNextOMSibling() throws OMException;
+
+ /**
+ * Indicates whether parser has parsed this information item completely or not.
+ * If some info are not available in the item, one has to check this attribute to make sure that, this
+ * item has been parsed completely or not.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isComplete();
+
+ /**
+ * Removes a node (and all of its children) from its containing parent.
+ *
+ * <p>Removes a node from its parent. Partially complete nodes will be completed before
+ * they are detached from the model. A node cannot be detached until its next sibling
+ * has been identified, so that the next sibling and parent can be updated appropriately.
+ * Please note that this will not handle the namespaces. For example, if there you have used a
+ * namespace within the detaching node and which is defined outside the detaching node, user has
+ * to handle it manually.
+ * </p>
+ *
+ * @throws OMException If a node is not complete, the detach can trigger further
+ * parsing, which may cause an exception.
+ */
+ public OMNode detach() throws OMException;
+
+ /**
+ * Discards a node.
+ *
+ * <p>Discard goes to the parser level and if the element is not completely built, then it will be
+ * completely skipped at the parser level.</p>
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException;
+
+ /**
+ * Inserts a new sibling after the current node.
+ *
+ * @param sibling The node that will be added after the current node.
+ *
+ * @throws OMException
+ */
+ public void insertSiblingAfter(OMNode sibling) throws OMException;
+
+ /**
+ * Inserts a sibling just before the current node.
+ *
+ * @param sibling The node that will be added before the current node.
+ * @throws OMException
+ */
+ public void insertSiblingBefore(OMNode sibling) throws OMException;
+
+ /**
+ * Returns the type of node.
+ *
+ * @return Returns one of {@link #ELEMENT_NODE}, {@link #TEXT_NODE}, {@link #CDATA_SECTION_NODE}, {@link #COMMENT_NODE},
+ * {@link #DTD_NODE}, {@link #PI_NODE}, {@link #ENTITY_REFERENCE_NODE}, {@link #SPACE_NODE},
+ * or {@link #TEXT_NODE}.
+ */
+ public int getType();
+
+ /**
+ * Gets the previous sibling.
+ *
+ * @return Returns node.
+ */
+ public OMNode getPreviousOMSibling();
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param xmlWriter
+ * @throws XMLStreamException
+ */
+ public void serialize(XMLStreamWriter xmlWriter)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param writer
+ * @throws XMLStreamException
+ */
+ public void serialize(Writer writer)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output, OMOutputFormat format)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param writer
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serialize(Writer writer, OMOutputFormat format)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param xmlWriter
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(XMLStreamWriter xmlWriter) throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output) throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param writer
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(Writer writer) throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output, OMOutputFormat format) throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param writer
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(Writer writer, OMOutputFormat format) throws XMLStreamException;
+
+ /**
+ * Builds itself.
+ */
+ public void build();
+}
diff --git a/src/org/apache/ws/commons/om/OMOutputFormat.java b/src/org/apache/ws/commons/om/OMOutputFormat.java
new file mode 100644
index 0000000..54ca345
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMOutputFormat.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.MIMEOutputUtils;
+import org.apache.ws.commons.om.util.UUIDGenerator;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+
+
+/**
+ * Formats options for OM Output.
+ */
+public class OMOutputFormat {
+ private String mimeBoundary = null;
+ private String rootContentId = null;
+ private int nextid = 0;
+ private boolean doOptimize;
+ private boolean isSoap11 = true;
+
+ /**
+ * Field DEFAULT_CHAR_SET_ENCODING. Specifies the default
+ * character encoding scheme to be used.
+ */
+ public static final String DEFAULT_CHAR_SET_ENCODING = "utf-8";
+
+ private String charSetEncoding;
+ private String xmlVersion;
+ private boolean ignoreXMLDeclaration = false;
+
+
+ public OMOutputFormat() {
+ }
+
+ public boolean isOptimized() {
+ return doOptimize;
+ }
+
+ public String getContentType() {
+ String SOAPContentType;
+ if (isOptimized()) {
+ if (isSoap11) {
+ SOAPContentType = SOAP11Constants.SOAP_11_CONTENT_TYPE;
+ } else {
+ SOAPContentType = SOAP12Constants.SOAP_12_CONTENT_TYPE;
+ }
+ return MIMEOutputUtils.getContentTypeForMime(
+ getMimeBoundary(),
+ getRootContentId(),
+ this.getCharSetEncoding(), SOAPContentType);
+ } else {
+ if (!isSoap11) {
+ return SOAP12Constants.SOAP_12_CONTENT_TYPE;
+ } else {
+ return SOAP11Constants.SOAP_11_CONTENT_TYPE;
+ }
+ }
+ }
+
+ public String getMimeBoundary() {
+ if (mimeBoundary == null) {
+ mimeBoundary =
+ "MIMEBoundary"
+ + UUIDGenerator.getUUID();
+ }
+ return mimeBoundary;
+ }
+
+ public String getRootContentId() {
+ if (rootContentId == null) {
+ rootContentId =
+ "0."
+ + UUIDGenerator.getUUID()
+ + "@apache.org";
+ }
+ return rootContentId;
+ }
+
+ public String getNextContentId() {
+ nextid++;
+ return nextid
+ + "."
+ + UUIDGenerator.getUUID()
+ + "@apache.org";
+ }
+
+ /**
+ * Returns the character set encoding scheme. If the value of the
+ * charSetEncoding is not set then the default will be returned.
+ *
+ * @return Returns encoding string.
+ */
+ public String getCharSetEncoding() {
+ return this.charSetEncoding;
+ }
+
+ public void setCharSetEncoding(String charSetEncoding) {
+ this.charSetEncoding = charSetEncoding;
+ }
+
+ public String getXmlVersion() {
+ return xmlVersion;
+ }
+
+ public void setXmlVersion(String xmlVersion) {
+ this.xmlVersion = xmlVersion;
+ }
+
+ public void setSOAP11(boolean b) {
+ isSoap11 = b;
+ }
+
+ public boolean isSOAP11() {
+ return isSoap11;
+ }
+
+ public boolean isIgnoreXMLDeclaration() {
+ return ignoreXMLDeclaration;
+ }
+
+ public void setIgnoreXMLDeclaration(boolean ignoreXMLDeclaration) {
+ this.ignoreXMLDeclaration = ignoreXMLDeclaration;
+ }
+
+ public void setDoOptimize(boolean b) {
+ doOptimize = b;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/OMProcessingInstruction.java b/src/org/apache/ws/commons/om/OMProcessingInstruction.java
new file mode 100644
index 0000000..62caef1
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMProcessingInstruction.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMProcessingInstruction
+ */
+public interface OMProcessingInstruction extends OMNode {
+ /**
+ * Sets the target of this Processing Instruction.
+ * @param target
+ */
+ public void setTarget(String target);
+
+ /**
+ * Gets the target of this Processing Instruction.
+ * @return Returns string.
+ */
+ public String getTarget();
+
+ /**
+ * Sets the value of this Processing Instruction.
+ * @param value
+ */
+ public void setValue(String value);
+
+ /**
+ * Gets the value of this Processing Instruction.
+ * @return Returns String.
+ */
+ public String getValue();
+}
diff --git a/src/org/apache/ws/commons/om/OMSerializer.java b/src/org/apache/ws/commons/om/OMSerializer.java
new file mode 100644
index 0000000..ba60136
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMSerializer.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ * Interface OMSerializer
+ */
+public interface OMSerializer {
+ /**
+ * Method serializeAndConsume
+ *
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ void serialize(XMLStreamReader reader, XMLStreamWriter writer)
+ throws XMLStreamException;
+}
diff --git a/src/org/apache/ws/commons/om/OMText.java b/src/org/apache/ws/commons/om/OMText.java
new file mode 100644
index 0000000..d3054ac
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMText.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+
+/**
+ * Interface OMText
+ */
+public interface OMText extends OMNode {
+ /**
+ * Returns the text value of this node.
+ *
+ * @return Returns String.
+ */
+ String getText();
+
+ /**
+ * Gets the datahandler.
+ * @return Returns datahandler.
+ */
+ Object getDataHandler();
+
+ /**
+ * @return Returns boolean flag saying whether the node contains
+ * an optimized text or not.
+ */
+ boolean isOptimized();
+
+ /**
+ * Sets the optimize flag.
+ * @param value
+ */
+ void setOptimize(boolean value);
+
+ /**
+ * Gets the content id.
+ * @return Returns String.
+ */
+ String getContentID();
+}
diff --git a/src/org/apache/ws/commons/om/OMXMLParserWrapper.java b/src/org/apache/ws/commons/om/OMXMLParserWrapper.java
new file mode 100644
index 0000000..da32d15
--- /dev/null
+++ b/src/org/apache/ws/commons/om/OMXMLParserWrapper.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * Interface OMXMLParserWrapper
+ */
+public interface OMXMLParserWrapper {
+ /**
+ * Proceed the parser one step and return the event value.
+ *
+ * @return Returns int.
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ * @throws OMException
+ */
+ int next() throws OMException;
+
+ /**
+ * Discards the current element.
+ * This will remove the given element and its decendants.
+ *
+ * @param el
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ * @throws OMException
+ */
+ void discard(OMElement el) throws OMException;
+
+ /**
+ * @param b
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ * @throws OMException
+ */
+ void setCache(boolean b) throws OMException;
+
+ /**
+ * Allows to access the underlying parser. Since the parser
+ * depends on the underlying implementation, an Object is returned.
+ * However the implementations may have restrictions in letting access to
+ * the parser.
+ *
+ * @return Returns Object.
+ */
+ Object getParser();
+
+ /**
+ * @return Returns the complete status.
+ */
+ boolean isCompleted();
+
+ /**
+ * @return Returns the document element.
+ */
+ OMElement getDocumentElement();
+
+ /**
+ * Returns the type of the builder.
+ * Can be either PUSH_TYPE_BUILDER or PULL_TYPE_BUILDER.
+ *
+ * @return Returns short.
+ */
+ short getBuilderType();
+
+ /**
+ * Registers an external content handler. Especially useful for
+ * push type builders. Throws an unsupportedOperationException if
+ * such handler registration is not supported.
+ *
+ * @param obj
+ */
+ void registerExternalContentHandler(Object obj);
+
+ /**
+ * get the registered external content handler
+ *
+ * @return Returns Object.
+ */
+ Object getRegisteredContentHandler();
+}
diff --git a/src/org/apache/ws/commons/om/impl/MIMEOutputUtils.java b/src/org/apache/ws/commons/om/impl/MIMEOutputUtils.java
new file mode 100644
index 0000000..d2e8c33
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/MIMEOutputUtils.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMText;
+
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeBodyPart;
+import javax.activation.DataHandler;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.StringWriter;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+public class MIMEOutputUtils {
+
+ private static byte[] CRLF = { 13, 10 };
+
+ public static void complete(OutputStream outStream,
+ StringWriter writer, LinkedList binaryNodeList,
+ String boundary, String contentId, String charSetEncoding,String SOAPContentType) {
+ try {
+ startWritingMime(outStream, boundary);
+
+ javax.activation.DataHandler dh = new javax.activation.DataHandler(writer.toString(),
+ "text/xml; charset=" + charSetEncoding);
+ MimeBodyPart rootMimeBodyPart = new MimeBodyPart();
+ rootMimeBodyPart.setDataHandler(dh);
+
+ rootMimeBodyPart.addHeader("content-type",
+ "application/xop+xml; charset=" + charSetEncoding +
+ "; type=\""+SOAPContentType+"\";");
+ rootMimeBodyPart.addHeader("content-transfer-encoding", "binary");
+ rootMimeBodyPart.addHeader("content-id","<"+contentId+">");
+
+ writeBodyPart(outStream, rootMimeBodyPart, boundary);
+
+ Iterator binaryNodeIterator = binaryNodeList.iterator();
+ while (binaryNodeIterator.hasNext()) {
+ OMText binaryNode = (OMText) binaryNodeIterator.next();
+ writeBodyPart(outStream, createMimeBodyPart(binaryNode),
+ boundary);
+ }
+ finishWritingMime(outStream);
+ } catch (IOException e) {
+ throw new OMException("Problem with the OutputStream.", e);
+ } catch (MessagingException e) {
+ throw new OMException("Problem writing Mime Parts.", e);
+ }
+ }
+
+ public static MimeBodyPart createMimeBodyPart(OMText node)
+ throws MessagingException {
+ MimeBodyPart mimeBodyPart = new MimeBodyPart();
+ final DataHandler dataHandler = (DataHandler) node.getDataHandler();
+ mimeBodyPart.setDataHandler(dataHandler);
+ mimeBodyPart.addHeader("content-id", "<"+node.getContentID()+">");
+ mimeBodyPart.addHeader("content-type", dataHandler.getContentType());
+ mimeBodyPart.addHeader("content-transfer-encoding", "binary");
+ return mimeBodyPart;
+
+ }
+
+ /**
+ * @throws IOException This will write the boundary to output Stream
+ */
+ public static void writeMimeBoundary(OutputStream outStream,
+ String boundary) throws IOException {
+ outStream.write(new byte[]{45, 45});
+ outStream.write(boundary.getBytes());
+ }
+
+ /**
+ * @throws IOException This will write the boundary with CRLF
+ */
+ public static void startWritingMime(OutputStream outStream,
+ String boundary)
+ throws IOException {
+ writeMimeBoundary(outStream, boundary);
+ //outStream.write(CRLF);
+ }
+
+ /**
+ * Writes a CRLF for the earlier boundary then the BodyPart data
+ * with headers followed by boundary. Writes only the boundary. No more
+ * CRLF's are written after that.
+ *
+ * @throws IOException
+ * @throws MessagingException
+ */
+ public static void writeBodyPart(OutputStream outStream,
+ MimeBodyPart part,
+ String boundary) throws IOException,
+ MessagingException {
+ outStream.write(CRLF);
+ part.writeTo(outStream);
+ outStream.write(CRLF);
+ writeMimeBoundary(outStream, boundary);
+ }
+
+ /**
+ * @throws IOException This will write "--" to the end of last boundary
+ */
+ public static void finishWritingMime(OutputStream outStream)
+ throws IOException {
+ outStream.write(new byte[]{45, 45});
+ }
+
+ public static String getContentTypeForMime(String boundary, String contentId, String charSetEncoding, String SOAPContentType) {
+ StringBuffer sb = new StringBuffer();
+ sb.append("multipart/related");
+ sb.append("; ");
+ sb.append("boundary=");
+ sb.append(boundary);
+ sb.append("; ");
+ sb.append("type=\"application/xop+xml\"");
+ sb.append("; ");
+ sb.append("start=\"<" + contentId + ">\"");
+ sb.append("; ");
+ sb.append("start-info=\""+SOAPContentType+"\"");
+ return sb.toString();
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/MTOMConstants.java b/src/org/apache/ws/commons/om/impl/MTOMConstants.java
new file mode 100644
index 0000000..82d14e6
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/MTOMConstants.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl;
+
+public interface MTOMConstants {
+ public static final String XOP_INCLUDE = "Include";
+ public static final String XOP_NAMESPACE_URI = "http://www.w3.org/2004/08/xop/include";
+
+ /**
+ * If the Message is MTOM optimised then <code>MTOM_TYPE</code>
+ */
+ String MTOM_TYPE = "application/xop+xml";
+ /**
+ * If the message is Soap with Attachments <code>SWA_TYPE</code>
+ */
+ String SWA_TYPE = "text/xml";
+ /**
+ * <code>rootPart</code> is used as the key for the root BodyPart in the
+ * Parts HashMap
+ */
+ String ROOT_PART = "SoapPart";
+ String ATTACHMENTS = "Attachments";
+}
diff --git a/src/org/apache/ws/commons/om/impl/OMContainerEx.java b/src/org/apache/ws/commons/om/impl/OMContainerEx.java
new file mode 100644
index 0000000..c9d8fb0
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/OMContainerEx.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMNode;
+
+/**
+ * Interface OMContainerEx
+ *
+ * Internal Implementation detail. Adding special interface to stop folks from accidently using OMContainer.
+ * Please use at your own risk. May corrupt the data integrity.
+ */
+public interface OMContainerEx extends OMContainer {
+ public void setComplete(boolean state);
+
+ public void setFirstChild(OMNode omNode);
+}
diff --git a/src/org/apache/ws/commons/om/impl/OMNodeEx.java b/src/org/apache/ws/commons/om/impl/OMNodeEx.java
new file mode 100644
index 0000000..702d361
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/OMNodeEx.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+
+import javax.xml.stream.XMLStreamException;
+
+/**
+ * Interface OMNodeEx
+ *
+ * Internal Implementation detail. Adding special interface to stop folks from accidently using OMNode.
+ * Please use at your own risk. May corrupt the data integrity.
+ */
+public interface OMNodeEx extends OMNode {
+ public void setNextOMSibling(OMNode node);
+
+ public void setPreviousOMSibling(OMNode previousSibling);
+
+ public void setParent(OMContainer element);
+
+ public void setComplete(boolean state);
+
+ public void setType(int nodeType) throws OMException;
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param omOutput
+ * @throws javax.xml.stream.XMLStreamException
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput)
+ throws XMLStreamException;
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput) throws XMLStreamException;
+}
diff --git a/src/org/apache/ws/commons/om/impl/OMOutputImpl.java b/src/org/apache/ws/commons/om/impl/OMOutputImpl.java
new file mode 100644
index 0000000..7aa6aaa
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/OMOutputImpl.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl;
+
+import org.apache.ws.commons.om.OMOutputFormat;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+
+import javax.xml.stream.FactoryConfigurationError;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.OutputStream;
+import java.io.StringWriter;
+import java.util.LinkedList;
+
+
+/**
+ * For the moment this assumes that transport takes the decision of whether
+ * to optimize or not by looking at whether the MTOM optimize is enabled &
+ * also looking at the OM tree whether it has any optimizable content.
+ */
+public class OMOutputImpl {
+ private XMLStreamWriter xmlWriter;
+ private OutputStream outStream;
+ private LinkedList binaryNodeList = new LinkedList();
+ private StringWriter bufferedSOAPBody;
+ private OMOutputFormat format = new OMOutputFormat();
+
+ public OMOutputImpl(XMLStreamWriter xmlWriter) {
+ this.xmlWriter = xmlWriter;
+ }
+
+ /**
+ * Creates a new OMOutputImpl with specified encoding.
+ *
+ * @param outStream
+ * @param format
+ * @throws XMLStreamException
+ * @throws FactoryConfigurationError
+ * @see OMOutputFormat#DEFAULT_CHAR_SET_ENCODING
+ */
+ public OMOutputImpl(OutputStream outStream, OMOutputFormat format)
+ throws XMLStreamException, FactoryConfigurationError {
+ this.format = format;
+ this.outStream = outStream;
+
+ if (format.getCharSetEncoding() == null) //Default encoding is UTF-8
+ format.setCharSetEncoding(OMOutputFormat.DEFAULT_CHAR_SET_ENCODING);
+
+ XMLOutputFactory factory = XMLOutputFactory.newInstance();
+
+ if (format.isOptimized()) {
+ bufferedSOAPBody = new StringWriter();
+ xmlWriter = factory.createXMLStreamWriter(bufferedSOAPBody);
+ } else {
+ xmlWriter = factory.createXMLStreamWriter(outStream,
+ format.getCharSetEncoding());
+ }
+ }
+
+ public void flush() throws XMLStreamException {
+ xmlWriter.flush();
+ String SOAPContentType;
+ if (format.isOptimized()) {
+ if (format.isSOAP11()) {
+ SOAPContentType = SOAP11Constants.SOAP_11_CONTENT_TYPE;
+ } else {
+ SOAPContentType = SOAP12Constants.SOAP_12_CONTENT_TYPE;
+ }
+ MIMEOutputUtils.complete(
+ outStream,
+ bufferedSOAPBody,
+ binaryNodeList,
+ format.getMimeBoundary(),
+ format.getRootContentId(),
+ format.getCharSetEncoding(), SOAPContentType);
+ }
+ }
+
+ public boolean isOptimized() {
+ return format.isOptimized();
+ }
+
+ public String getContentType() {
+ return format.getContentType();
+ }
+
+ public void writeOptimized(OMText node) {
+ binaryNodeList.add(node);
+ }
+
+ public void setXmlStreamWriter(XMLStreamWriter xmlWriter) {
+ this.xmlWriter = xmlWriter;
+ }
+
+ public XMLStreamWriter getXmlStreamWriter() {
+ return xmlWriter;
+ }
+
+ public String getMimeBoundary() {
+ return format.getMimeBoundary();
+ }
+
+ public String getRootContentId() {
+ return format.getRootContentId();
+ }
+
+ public String getNextContentId() {
+ return format.getNextContentId();
+ }
+
+ /**
+ * Returns the character set encoding scheme. If the value of the
+ * charSetEncoding is not set then the default will be returned.
+ *
+ * @return Returns encoding.
+ */
+ public String getCharSetEncoding() {
+ return format.getCharSetEncoding();
+ }
+
+ public void setCharSetEncoding(String charSetEncoding) {
+ format.setCharSetEncoding(charSetEncoding);
+ }
+
+ public String getXmlVersion() {
+ return format.getXmlVersion();
+ }
+
+ public void setXmlVersion(String xmlVersion) {
+ format.setXmlVersion(xmlVersion);
+ }
+
+ public void setSoap11(boolean b) {
+ format.setSOAP11(b);
+ }
+
+ public boolean isIgnoreXMLDeclaration() {
+ return format.isIgnoreXMLDeclaration();
+ }
+
+ public void setIgnoreXMLDeclaration(boolean ignoreXMLDeclaration) {
+ format.setIgnoreXMLDeclaration(ignoreXMLDeclaration);
+ }
+
+ public void setDoOptimize(boolean b) {
+ format.setDoOptimize(b);
+ }
+
+ public void setOutputFormat(OMOutputFormat format) {
+ this.format = format;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/EmptyOMLocation.java b/src/org/apache/ws/commons/om/impl/llom/EmptyOMLocation.java
new file mode 100644
index 0000000..1d44fdc
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/EmptyOMLocation.java
@@ -0,0 +1,45 @@
+package org.apache.ws.commons.om.impl.llom;
+
+import javax.xml.stream.Location;
+
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ *
+ */
+
+public class EmptyOMLocation implements Location {
+
+
+ public int getLineNumber() {
+ return -1; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public int getColumnNumber() {
+ return -1; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public int getCharacterOffset() {
+ return 0; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public String getPublicId() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+ public String getSystemId() {
+ return null; //To change body of implemented methods use File | Settings | File Templates.
+ }
+
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMAttributeImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMAttributeImpl.java
new file mode 100644
index 0000000..29aeebc
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMAttributeImpl.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMNamespace;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Class OMAttributeImpl
+ */
+public class OMAttributeImpl implements OMAttribute {
+ /**
+ * Field localName
+ */
+ private String localName;
+
+ /**
+ * Field value
+ */
+ private String value;
+
+ /**
+ * Field namespace
+ */
+ private OMNamespace namespace;
+
+ /**
+ * Constructor OMAttributeImpl.
+ *
+ * @param localName
+ * @param ns
+ * @param value
+ */
+ public OMAttributeImpl(String localName, OMNamespace ns, String value) {
+ setLocalName(localName);
+ setAttributeValue(value);
+ setOMNamespace(ns);
+ }
+
+ /**
+ *
+ * @return Returns QName.
+ */
+ public QName getQName() {
+ if(namespace != null){
+ return new QName(namespace.getName(), localName, namespace.getPrefix());
+ }else{
+ return new QName(localName);
+ }
+ }
+
+ // -------- Getters and Setters
+
+ /**
+ * Method getLocalName.
+ *
+ * @return Returns local name.
+ */
+ public String getLocalName() {
+ return localName;
+ }
+
+ /**
+ * Method setLocalName.
+ *
+ * @param localName
+ */
+ public void setLocalName(String localName) {
+ this.localName = localName;
+ }
+
+ /**
+ * Method getAttributeValue.
+ *
+ * @return Returns value.
+ */
+ public String getAttributeValue() {
+ return value;
+ }
+
+ /**
+ * Method setAttributeValue.
+ *
+ * @param value
+ */
+ public void setAttributeValue(String value) {
+ this.value = value;
+ }
+
+ /**
+ * Method setOMNamespace.
+ *
+ * @param omNamespace
+ */
+ public void setOMNamespace(OMNamespace omNamespace) {
+ this.namespace = omNamespace;
+ }
+
+ /**
+ * Method getNamespace.
+ *
+ * @return Returns namespace.
+ */
+ public OMNamespace getNamespace() {
+ return namespace;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMCommentImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMCommentImpl.java
new file mode 100644
index 0000000..744804c
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMCommentImpl.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMComment;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class OMCommentImpl extends OMNodeImpl implements OMComment {
+ protected String value;
+
+ /**
+ * Constructor OMCommentImpl.
+ *
+ * @param parentNode
+ * @param contentText
+ */
+ public OMCommentImpl(OMContainer parentNode, String contentText) {
+ super(parentNode);
+ this.value = contentText;
+ nodeType = OMNode.COMMENT_NODE;
+ this.done = true;
+ }
+
+ /**
+ * Constructor OMCommentImpl.
+ *
+ * @param parentNode
+ */
+ public OMCommentImpl(OMContainer parentNode) {
+ this(parentNode, null);
+ }
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ writer.writeComment(this.value);
+ }
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput) throws XMLStreamException {
+ serialize(omOutput);
+ }
+
+ /**
+ * Gets the value of this comment.
+ *
+ * @return Returns String.
+ */
+ public String getValue() {
+ return value;
+ }
+
+ /**
+ * Sets the value of this comment.
+ *
+ * @param text
+ */
+ public void setValue(String text) {
+ this.value = text;
+ }
+
+ /**
+ * Discards this node.
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard((OMElement) this.parent);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMDocTypeImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMDocTypeImpl.java
new file mode 100644
index 0000000..8a54fd3
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMDocTypeImpl.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMDocType;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class OMDocTypeImpl extends OMNodeImpl implements OMDocType {
+ protected String value;
+
+ /**
+ * Constructor OMDocTypeImpl.
+ *
+ * @param parentNode
+ * @param contentText
+ */
+ public OMDocTypeImpl(OMContainer parentNode, String contentText) {
+ super(parentNode);
+ this.value = contentText;
+ nodeType = OMNode.DTD_NODE;
+ }
+
+ /**
+ * Constructor OMDocTypeImpl.
+ *
+ * @param parentNode
+ */
+ public OMDocTypeImpl(OMContainer parentNode) {
+ this(parentNode, null);
+ }
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ writer.writeDTD(this.value);
+ }
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ serialize(omOutput);
+ }
+
+ /**
+ * Gets the value of this DocType.
+ *
+ * @return Returns String.
+ */
+ public String getValue() {
+ return value;
+ }
+
+ /**
+ * Sets the value of this DocType.
+ *
+ * @param text
+ */
+ public void setValue(String text) {
+ this.value = text;
+ }
+
+ /**
+ * Discards this node.
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard((OMElement) this.parent);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMDocumentImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMDocumentImpl.java
new file mode 100644
index 0000000..5cb9328
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMDocumentImpl.java
@@ -0,0 +1,402 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMOutputFormat;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMContainerEx;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenIterator;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenQNameIterator;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import java.io.OutputStream;
+import java.util.Iterator;
+
+/**
+ * Class OMDocumentImpl
+ */
+public class OMDocumentImpl implements OMDocument, OMContainerEx {
+ /**
+ * Field documentElement
+ */
+ protected OMElement documentElement;
+
+ /**
+ * Field firstChild
+ */
+ protected OMNode firstChild;
+
+ /**
+ * Field lastChild
+ */
+ protected OMNode lastChild;
+
+ /**
+ * Field done
+ */
+ protected boolean done = false;
+
+ /**
+ * Field parserWrapper
+ */
+ protected OMXMLParserWrapper parserWrapper;
+
+ /**
+ * Field charSetEncoding
+ * Default : UTF-8
+ */
+ protected String charSetEncoding = "UTF-8";
+
+ /**
+ * Field xmlVersion
+ */
+ protected String xmlVersion = "1.0";
+
+ protected String isStandalone;
+
+
+ /**
+ * Default constructor
+ */
+ public OMDocumentImpl() {
+ this.done = true;
+ }
+
+ /**
+ * @param documentElement
+ * @param parserWrapper
+ */
+ public OMDocumentImpl(OMElement documentElement, OMXMLParserWrapper parserWrapper) {
+ this.documentElement = documentElement;
+ this.parserWrapper = parserWrapper;
+ }
+
+ /**
+ * @param parserWrapper
+ */
+ public OMDocumentImpl(OMXMLParserWrapper parserWrapper) {
+ this.parserWrapper = parserWrapper;
+ }
+
+ /**
+ * Method getDocumentElement.
+ *
+ * @return Returns OMElement.
+ */
+ public OMElement getOMDocumentElement() {
+ while (documentElement == null) {
+ parserWrapper.next();
+ }
+ return documentElement;
+ }
+
+ /**
+ * Method setDocumentElement.
+ *
+ * @param documentElement
+ */
+ public void setOMDocumentElement(OMElement documentElement) {
+ this.documentElement = documentElement;
+ }
+
+ /**
+ * Indicates whether parser has parsed this information item completely or not.
+ * If some information is not available in the item, one has to check this
+ * attribute to make sure that, this item has been parsed completely or not.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isComplete() {
+ return done;
+ }
+
+ /**
+ * Method setComplete.
+ *
+ * @param state
+ */
+ public void setComplete(boolean state) {
+ this.done = state;
+ }
+
+ /**
+ * Forces the parser to proceed, if parser has not yet finished with the XML input.
+ */
+ public void buildNext() {
+ if (!parserWrapper.isCompleted())
+ parserWrapper.next();
+ }
+
+ /**
+ * Adds child to the element. One can decide whether to append the child or to add to the
+ * front of the children list.
+ *
+ * @param child
+ */
+ public void addChild(OMNode child) {
+ if(child instanceof OMElement) {
+ if(this.documentElement == null) {
+ addChild((OMNodeImpl) child);
+ this.documentElement = (OMElement)child;
+ } else {
+ throw new OMException("Document element already exists");
+ }
+ } else {
+ addChild((OMNodeImpl) child);
+ }
+ }
+
+ /**
+ * Method addChild.
+ *
+ * @param child
+ */
+ private void addChild(OMNodeImpl child) {
+ if (firstChild == null) {
+ firstChild = child;
+ child.setPreviousOMSibling(null);
+ } else {
+ child.setPreviousOMSibling(lastChild);
+ ((OMNodeEx)lastChild).setNextOMSibling(child);
+ }
+ child.setNextOMSibling(null);
+ child.setParent(this);
+ lastChild = child;
+
+ }
+
+ /**
+ * Returns a collection of this element.
+ * Children can be of types OMElement, OMText.
+ *
+ * @return Returns iterator.
+ */
+ public Iterator getChildren() {
+ return new OMChildrenIterator(getFirstOMChild());
+ }
+
+ /**
+ * Searches for children with a given QName and returns an iterator to traverse through
+ * the OMNodes.
+ * The QName can contain any combination of prefix, localname and URI.
+ *
+ * @param elementQName
+ * @return Returns Iterator.
+ * @throws org.apache.ws.commons.om.OMException
+ */
+ public Iterator getChildrenWithName(QName elementQName) {
+ return new OMChildrenQNameIterator(getFirstOMChild(),
+ elementQName);
+ }
+
+ /**
+ * Method getFirstOMChild.
+ *
+ * @return Returns first om child.
+ */
+ public OMNode getFirstOMChild() {
+ while ((firstChild == null) && !done) {
+ buildNext();
+ }
+ return firstChild;
+ }
+
+ /**
+ * Method getFirstChildWithName.
+ *
+ * @param elementQName
+ * @return Returns OMElement.
+ * @throws OMException
+ */
+ public OMElement getFirstChildWithName(QName elementQName) throws OMException {
+ OMChildrenQNameIterator omChildrenQNameIterator =
+ new OMChildrenQNameIterator(getFirstOMChild(),
+ elementQName);
+ OMNode omNode = null;
+ if (omChildrenQNameIterator.hasNext()) {
+ omNode = (OMNode) omChildrenQNameIterator.next();
+ }
+
+ return ((omNode != null) && (OMNode.ELEMENT_NODE == omNode.getType())) ?
+ (OMElement) omNode : null;
+
+ }
+
+ /**
+ * Method setFirstChild.
+ *
+ * @param firstChild
+ */
+ public void setFirstChild(OMNode firstChild) {
+ this.firstChild = firstChild;
+ }
+
+
+ /**
+ * Returns the character set encoding scheme to be used.
+ *
+ * @return Returns charset.
+ */
+ public String getCharsetEncoding() {
+ return charSetEncoding;
+ }
+
+ /**
+ * Sets the character set encoding scheme.
+ *
+ * @param charEncoding
+ */
+ public void setCharsetEncoding(String charEncoding) {
+ this.charSetEncoding = charEncoding;
+ }
+
+ public String isStandalone() {
+ return isStandalone;
+ }
+
+ public void setStandalone(String isStandalone) {
+ this.isStandalone = isStandalone;
+ }
+
+ public String getXMLVersion() {
+ return xmlVersion;
+ }
+
+ public void setXMLVersion(String xmlVersion) {
+ this.xmlVersion = xmlVersion;
+ }
+
+ /**
+ * Serialize the docuement with/without the XML declaration
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput, boolean includeXMLDeclaration) throws XMLStreamException {
+ serialize(omOutput, false, includeXMLDeclaration);
+ }
+
+ /**
+ * Serializes the document with the XML declaration.
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ serialize(omOutput, false, !omOutput.isIgnoreXMLDeclaration());
+ }
+
+
+ /**
+ * Serializes the document with cache.
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ serialize(omOutput, true, !omOutput.isIgnoreXMLDeclaration());
+
+ }
+
+ /**
+ * Serializes the document directly to the output stream with caching disabled.
+ *
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, new OMOutputFormat());
+ serializeAndConsume(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the document directly to the output stream with caching enabled.
+ *
+ * @param output
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, new OMOutputFormat());
+ serialize(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the document directly to the output stream with caching disabled.
+ *
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, format);
+ serializeAndConsume(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the document directly to the output stream with caching enabled.
+ *
+ * @param output
+ * @param format
+ * @throws XMLStreamException
+ */
+ public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, format);
+ serialize(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the document with cache.
+ */
+ public void serialize(OMOutputImpl omOutput, boolean includeXMLDeclaration) throws XMLStreamException {
+ serialize(omOutput, true, includeXMLDeclaration);
+
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache, boolean includeXMLDeclaration) throws XMLStreamException {
+ if (includeXMLDeclaration) {
+ //Check whether the OMOutput char encoding and OMDocument char
+ //encoding matches, if not use char encoding of OMOutput
+ String outputCharEncoding = omOutput.getCharSetEncoding();
+ if (outputCharEncoding == null || "".equals(outputCharEncoding)) {
+ omOutput.getXmlStreamWriter().writeStartDocument(charSetEncoding,
+ xmlVersion);
+ } else {
+ omOutput.getXmlStreamWriter().writeStartDocument(outputCharEncoding,
+ xmlVersion);
+ }
+ }
+
+ Iterator children = this.getChildren();
+
+ if (cache) {
+ while (children.hasNext()) {
+ OMNodeEx omNode = (OMNodeEx) children.next();
+ omNode.serialize(omOutput);
+ }
+ } else {
+ while (children.hasNext()) {
+ OMNodeEx omNode = (OMNodeEx) children.next();
+ omNode.serializeAndConsume(omOutput);
+ }
+ }
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMElementImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMElementImpl.java
new file mode 100644
index 0000000..37981bf
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMElementImpl.java
@@ -0,0 +1,862 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMContainerEx;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildElementIterator;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenIterator;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenQNameIterator;
+import org.apache.ws.commons.om.impl.llom.util.EmptyIterator;
+import org.apache.ws.commons.om.util.ElementHelper;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayOutputStream;
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * Class OMElementImpl
+ */
+public class OMElementImpl extends OMNodeImpl
+ implements OMElement, OMConstants, OMContainerEx {
+ /**
+ * Field ns
+ */
+ protected OMNamespace ns;
+
+ /**
+ * Field localName
+ */
+ protected String localName;
+ /**
+ * Field firstChild
+ */
+ protected OMNode firstChild;
+
+ /**
+ * Field namespaces
+ */
+ protected HashMap namespaces = null;
+
+ /**
+ * Field attributes
+ */
+ protected HashMap attributes = null;
+
+ /**
+ * Field noPrefixNamespaceCounter
+ */
+ protected int noPrefixNamespaceCounter = 0;
+ private OMNode lastChild;
+ private int lineNumber;
+
+ /**
+ * Constructor OMElementImpl.
+ */
+ public OMElementImpl(String localName, OMNamespace ns, OMContainer parent,
+ OMXMLParserWrapper builder) {
+ super(parent);
+ this.localName = localName;
+ if (ns != null) {
+ setNamespace(ns);
+ }
+ this.builder = builder;
+ firstChild = null;
+ }
+
+
+ /**
+ * Constructor OMElementImpl.
+ */
+ public OMElementImpl(String localName, OMNamespace ns) {
+ this(localName, ns, null);
+ }
+
+ /**
+ * This is the basic constructor for OMElement. All the other constructors
+ * depends on this.
+ *
+ * @param localName - this MUST always be not null
+ * @param ns - can be null
+ * @param parent - this should be an OMContainer
+ */
+ public OMElementImpl(String localName, OMNamespace ns, OMContainer parent) {
+ super(parent);
+ if (localName == null || localName.trim().length() == 0) {
+ throw new OMException("localname can not be null or empty");
+ }
+ this.localName = localName;
+ this.done = true;
+ if (ns != null) {
+ setNamespace(ns);
+ }
+ }
+
+ /**
+ * It is assumed that the QName passed contains, at least, the localName for this element.
+ *
+ * @param qname - this should be valid qname according to javax.xml.namespace.QName
+ * @throws OMException
+ */
+ public OMElementImpl(QName qname, OMContainer parent) throws OMException {
+ this(qname.getLocalPart(), null, parent);
+ this.ns = handleNamespace(qname);
+ }
+
+ /**
+ * Method handleNamespace.
+ */
+ private OMNamespace handleNamespace(QName qname) {
+ OMNamespace ns = null;
+
+ // first try to find a namespace from the scope
+ String namespaceURI = qname.getNamespaceURI();
+ if (namespaceURI != null && namespaceURI.length() > 0) {
+ ns = findNamespace(qname.getNamespaceURI(),
+ qname.getPrefix());
+
+ /**
+ * What is left now is
+ * 1. nsURI = null & parent != null, but ns = null
+ * 2. nsURI != null, (parent doesn't have an ns with given URI), but ns = null
+ */
+ if (ns == null) {
+ String prefix = qname.getPrefix();
+ ns = declareNamespace(namespaceURI, prefix);
+ }
+ if (ns != null) {
+ this.ns = (ns);
+ }
+ }
+
+ else
+
+ {
+ // no namespace URI in the given QName. No need to bother about this ??
+ }
+
+ return ns;
+ }
+
+ /**
+ * Method handleNamespace.
+ *
+ * @return Returns namespace.
+ */
+ private OMNamespace handleNamespace(OMNamespace ns) {
+ OMNamespace namespace = findNamespace(ns.getName(),
+ ns.getPrefix());
+ if (namespace == null) {
+ namespace = declareNamespace(ns);
+ }
+ return namespace;
+ }
+
+ /**
+ * Adds child to the element. One can decide whether to append the child or to add to the
+ * front of the children list.
+ */
+ public void addChild(OMNode child) {
+ addChild((OMNodeImpl) child);
+ }
+
+ /**
+ * Searches for children with a given QName and returns an iterator to traverse through
+ * the OMNodes.
+ * This QName can contain any combination of prefix, localname and URI.
+ *
+ * @throws OMException
+ */
+ public Iterator getChildrenWithName(QName elementQName) {
+ return new OMChildrenQNameIterator(getFirstOMChild(),
+ elementQName);
+ }
+
+ /**
+ * Method getFirstChildWithName.
+ *
+ * @throws OMException
+ */
+ public OMElement getFirstChildWithName(QName elementQName) throws OMException {
+ OMChildrenQNameIterator omChildrenQNameIterator =
+ new OMChildrenQNameIterator(getFirstOMChild(),
+ elementQName);
+ OMNode omNode = null;
+ if (omChildrenQNameIterator.hasNext()) {
+ omNode = (OMNode) omChildrenQNameIterator.next();
+ }
+
+ return ((omNode != null) && (OMNode.ELEMENT_NODE == omNode.getType())) ?
+ (OMElement) omNode : null;
+
+ }
+
+ /**
+ * Method addChild.
+ */
+ private void addChild(OMNodeImpl child) {
+ //the order of these statements is VERY important
+ //Since setting the parent has a detach method inside
+ //it strips down all the rerefences to siblings.
+ //setting the siblings should take place AFTER setting the parent
+
+ child.setParent(this);
+
+ if (firstChild == null) {
+ firstChild = child;
+ child.setPreviousOMSibling(null);
+ } else {
+ child.setPreviousOMSibling(lastChild);
+ ((OMNodeEx) lastChild).setNextOMSibling(child);
+ }
+
+ child.setNextOMSibling(null);
+ lastChild = child;
+
+ }
+
+ /**
+ * Gets the next sibling. This can be an OMAttribute or OMText or
+ * OMELement for others.
+ *
+ * @throws OMException
+ */
+ public OMNode getNextOMSibling() throws OMException {
+ while (!done) {
+ int token = builder.next();
+ if (token == XMLStreamConstants.END_DOCUMENT) {
+ throw new OMException();
+ }
+ }
+ return super.getNextOMSibling();
+ }
+
+ /**
+ * Returns a collection of this element. Children can be of types OMElement, OMText.
+ *
+ * @return Returns children.
+ */
+ public Iterator getChildren() {
+ return new OMChildrenIterator(getFirstOMChild());
+ }
+
+ /**
+ * Returns a filtered list of children - just the elements.
+ *
+ * @return Returns an iterator of the child elements.
+ */
+ public Iterator getChildElements() {
+ return new OMChildElementIterator(getFirstElement());
+ }
+
+ /**
+ * Creates a namespace in the current element scope.
+ *
+ * @return Returns namespace.
+ */
+ public OMNamespace declareNamespace(String uri, String prefix) {
+ OMNamespaceImpl ns = new OMNamespaceImpl(uri, prefix);
+ return declareNamespace(ns);
+ }
+
+ /**
+ * @return Returns namespace.
+ */
+ public OMNamespace declareNamespace(OMNamespace namespace) {
+ if (namespaces == null) {
+ this.namespaces = new HashMap(5);
+ }
+ namespaces.put(namespace.getPrefix(), namespace);
+ return namespace;
+ }
+
+ /**
+ * Finds a namespace with the given uri and prefix, in the scope of the document.
+ * Starts to find from the current element and goes up in the hiararchy until one is found.
+ * If none is found, returns null.
+ */
+ public OMNamespace findNamespace(String uri, String prefix) {
+
+ // check in the current element
+ OMNamespace namespace = findDeclaredNamespace(uri, prefix);
+ if (namespace != null) {
+ return namespace;
+ }
+
+ // go up to check with ancestors
+ if (parent != null) {
+ //For the OMDocumentImpl there won't be any explicit namespace
+ //declarations, so going up the parent chain till the document
+ //element should be enough.
+ if (parent instanceof OMElement) {
+ namespace = ((OMElementImpl) parent).findNamespace(uri, prefix);
+ }
+ }
+
+ return namespace;
+ }
+
+ public OMNamespace findNamespaceURI(String prefix) {
+ OMNamespace ns = (OMNamespace) this.namespaces.get(prefix);
+ if (ns == null && this.parent instanceof OMElement) {
+ // try with the parent
+ ns = ((OMElement) this.parent).findNamespaceURI(prefix);
+ }
+ return ns;
+ }
+
+ /**
+ * Checks for the namespace <B>only</B> in the current Element.
+ * This is also used to retrieve the prefix of a known namespace URI.
+ */
+ private OMNamespace findDeclaredNamespace(String uri, String prefix) {
+
+
+ if (uri == null) {
+ return null;
+ }
+
+ //If the prefix is available and uri is available and its the xml namespace
+ if (prefix != null && prefix.equals(OMConstants.XMLNS_PREFIX) && uri.equals(OMConstants.XMLNS_URI)) {
+ return new OMNamespaceImpl(uri, prefix);
+ }
+
+ if (namespaces == null) {
+ return null;
+ }
+
+ if (prefix == null || "".equals(prefix)) {
+ Iterator namespaceListIterator = namespaces.values().iterator();
+
+ OMNamespace ns = null;
+
+ while (namespaceListIterator.hasNext()) {
+ OMNamespace omNamespace =
+ (OMNamespace) namespaceListIterator.next();
+ if (omNamespace.getName() != null &&
+ omNamespace.getName().equals(uri)) {
+ if(ns == null){
+ ns = omNamespace;
+ }else{
+ if(omNamespace.getPrefix() == null || omNamespace.getPrefix().length() == 0){
+ ns = omNamespace;
+ }
+ }
+ }
+ }
+ return ns;
+ } else {
+ OMNamespace namespace = (OMNamespace) namespaces.get(prefix);
+ if (namespace != null && uri.equalsIgnoreCase(namespace.getName())) {
+ return namespace;
+ } else {
+ return null;
+ }
+ }
+ }
+
+
+ /**
+ * Method getAllDeclaredNamespaces.
+ *
+ * @return Returns Iterator.
+ */
+ public Iterator getAllDeclaredNamespaces() {
+ if (namespaces == null) {
+ return new Iterator() {
+ public void remove() {
+ throw new UnsupportedOperationException();
+ }
+
+ public boolean hasNext() {
+ return false;
+ }
+
+ public Object next() {
+ return null;
+ }
+ };
+ }
+ return namespaces.values().iterator();
+ }
+
+ /**
+ * Returns a List of OMAttributes.
+ *
+ * @return Returns iterator.
+ */
+ public Iterator getAllAttributes() {
+ if (attributes == null) {
+ return new EmptyIterator();
+ }
+ return attributes.values().iterator();
+ }
+
+ /**
+ * Returns a named attribute if present.
+ *
+ * @param qname the qualified name to search for
+ * @return Returns an OMAttribute with the given name if found, or null
+ */
+ public OMAttribute getAttribute(QName qname) {
+ return attributes == null ? null : (OMAttribute) attributes.get(qname);
+ }
+
+ /**
+ * Returns a named attribute's value, if present.
+ *
+ * @param qname the qualified name to search for
+ * @return Returns a String containing the attribute value, or null.
+ */
+ public String getAttributeValue(QName qname) {
+ OMAttribute attr = getAttribute(qname);
+ return (attr == null) ? null : attr.getAttributeValue();
+ }
+
+ /**
+ * Inserts an attribute to this element. Implementor can decide as to insert this
+ * in the front or at the end of set of attributes.
+ *
+ * @return Returns attribute.
+ */
+ public OMAttribute addAttribute(OMAttribute attr) {
+ if (attributes == null) {
+ this.attributes = new HashMap(5);
+ }
+ OMNamespace namespace = attr.getNamespace();
+ if (namespace != null && this.findNamespace(namespace.getName(), namespace.getPrefix()) == null) {
+ this.declareNamespace(namespace.getName(), namespace.getPrefix());
+ }
+
+ attributes.put(attr.getQName(), attr);
+ return attr;
+ }
+
+ /**
+ * Method removeAttribute.
+ */
+ public void removeAttribute(OMAttribute attr) {
+ if (attributes != null) {
+ attributes.remove(attr.getQName());
+ }
+ }
+
+ /**
+ * Method addAttribute.
+ *
+ * @return Returns OMAttribute.
+ */
+ public OMAttribute addAttribute(String attributeName, String value,
+ OMNamespace ns) {
+ OMNamespace namespace;
+ if (ns != null) {
+ namespace = findNamespace(ns.getName(), ns.getPrefix());
+ if (namespace == null) {
+ throw new OMException("Given OMNamespace(" + ns.getName() +
+ ns.getPrefix()
+ + ") for "
+ +
+ "this attribute is not declared in the scope of this element. First declare the namespace"
+ + " and then use it with the attribute");
+ }
+ }
+ return addAttribute(new OMAttributeImpl(attributeName, ns, value));
+ }
+
+ /**
+ * Method setBuilder.
+ */
+ public void setBuilder(OMXMLParserWrapper wrapper) {
+ this.builder = wrapper;
+ }
+
+ /**
+ * Method getBuilder.
+ *
+ * @return Returns OMXMLParserWrapper.
+ */
+ public OMXMLParserWrapper getBuilder() {
+ return builder;
+ }
+
+ /**
+ * Forces the parser to proceed, if parser has not yet finished with the XML input.
+ */
+ public void buildNext() {
+ builder.next();
+ }
+
+ /**
+ * Method getFirstOMChild.
+ *
+ * @return Returns child.
+ */
+ public OMNode getFirstOMChild() {
+ while ((firstChild == null) && !done) {
+ buildNext();
+ }
+ return firstChild;
+ }
+
+ /**
+ * Method setFirstChild.
+ */
+ public void setFirstChild(OMNode firstChild) {
+ if (firstChild != null) {
+ ((OMNodeEx) firstChild).setParent(this);
+ }
+ this.firstChild = firstChild;
+ }
+
+ /**
+ * Removes this information item and its children, from the model completely.
+ *
+ * @throws OMException
+ */
+ public OMNode detach() throws OMException {
+ if (!done) {
+ build();
+ } else {
+ super.detach();
+ }
+ return this;
+ }
+
+ /**
+ * Method isComplete.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isComplete() {
+ return done;
+ }
+
+ /**
+ * Gets the type of node, as this is the super class of all the nodes.
+ */
+ public int getType() {
+ return OMNode.ELEMENT_NODE;
+ }
+
+ /**
+ * Method getXMLStreamReader.
+ *
+ * @see OMElement#getXMLStreamReader()
+ */
+ public XMLStreamReader getXMLStreamReader() {
+ return getXMLStreamReader(true);
+ }
+
+ /**
+ * Method getXMLStreamReaderWithoutCaching.
+ *
+ * @see OMElement#getXMLStreamReaderWithoutCaching()
+ */
+ public XMLStreamReader getXMLStreamReaderWithoutCaching() {
+ return getXMLStreamReader(false);
+ }
+
+ /**
+ * Method getXMLStreamReader.
+ *
+ * @return Returns reader.
+ */
+ private XMLStreamReader getXMLStreamReader(boolean cache) {
+ if ((builder == null) && !cache) {
+ throw new UnsupportedOperationException(
+ "This element was not created in a manner to be switched");
+ }
+ if (builder != null && builder.isCompleted() && !cache) {
+ throw new UnsupportedOperationException(
+ "The parser is already consumed!");
+ }
+ return new OMStAXWrapper(builder, this, cache);
+ }
+
+ /**
+ * Sets the text of the given element.
+ * caution - This method will wipe out all the text elements (and hence any
+ * mixed content) before setting the text.
+ */
+ public void setText(String text) {
+
+ OMNode child = this.getFirstOMChild();
+ while (child != null) {
+ if (child.getType() == OMNode.TEXT_NODE) {
+ child.detach();
+ }
+ child = child.getNextOMSibling();
+ }
+
+ this.addChild(OMAbstractFactory.getOMFactory().createText(this, text));
+ }
+
+ /**
+ * Selects all the text children and concatinates them to a single string.
+ *
+ * @return Returns String.
+ */
+ public String getText() {
+ String childText = "";
+ OMNode child = this.getFirstOMChild();
+ OMText textNode;
+
+ while (child != null) {
+ if (child.getType() == OMNode.TEXT_NODE) {
+ textNode = (OMText) child;
+ if (textNode.getText() != null &&
+ !"".equals(textNode.getText())) {
+ childText += textNode.getText();
+ }
+ }
+ child = child.getNextOMSibling();
+ }
+
+ return childText;
+ }
+
+ /**
+ * Returns the concatination string of TRIMMED values of all
+ * OMText child nodes of this element.
+ * This is included purely to improve usability.
+ */
+ public String getTrimmedText() {
+ String childText = "";
+ OMNode child = this.getFirstOMChild();
+ OMText textNode;
+
+ while (child != null) {
+ if (child.getType() == OMNode.TEXT_NODE) {
+ textNode = (OMText) child;
+ if (textNode.getText() != null &&
+ !"".equals(textNode.getText().trim())) {
+ childText += textNode.getText().trim();
+ }
+ }
+ child = child.getNextOMSibling();
+ }
+
+ return childText;
+ }
+
+ /**
+ * Method serialize.
+ *
+ * @throws XMLStreamException
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ serialize(omOutput, true);
+ }
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ if (cache) {
+ //in this case we don't care whether the elements are built or not
+ //we just call the serializeAndConsume methods
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ //serialize children
+ Iterator children = this.getChildren();
+ while (children.hasNext()) {
+ ((OMNodeEx) children.next()).serialize(omOutput);
+ }
+ OMSerializerUtil.serializeEndpart(omOutput);
+
+ } else {
+ //Now the caching is supposed to be off. However caching been switched off
+ //has nothing to do if the element is already built!
+ if (this.done) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ OMNodeImpl child = (OMNodeImpl) firstChild;
+ while(child != null && ((!(child instanceof OMElement)) || child.isComplete())) {
+ child.serializeAndConsume(omOutput);
+ child = child.nextSibling;
+ }
+ if(child != null) {
+ OMElement element = (OMElement) child;
+ element.getBuilder().setCache(false);
+ OMSerializerUtil.serializeByPullStream(element, omOutput, cache);
+ }
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else {
+ OMSerializerUtil.serializeByPullStream(this, omOutput, cache);
+ }
+
+
+ }
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * This method serializes and consumes without building the object structure in memory.
+ * Misuse of this method will cause loss of data. So it is advised to use
+ * populateYourSelf() method, before calling this method, if one wants to
+ * preserve data in the stream. This was requested during the second Axis2 summit.
+ *
+ * @throws XMLStreamException
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput) throws XMLStreamException {
+ this.serialize(omOutput, false);
+ }
+
+ /**
+ * Gets first element.
+ *
+ * @return Returns element.
+ */
+ public OMElement getFirstElement() {
+ OMNode node = getFirstOMChild();
+ while (node != null) {
+ if (node.getType() == OMNode.ELEMENT_NODE) {
+ return (OMElement) node;
+ } else {
+ node = node.getNextOMSibling();
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Method getLocalName.
+ *
+ * @return Returns local name.
+ */
+ public String getLocalName() {
+ return localName;
+ }
+
+ /**
+ * Method setLocalName.
+ */
+ public void setLocalName(String localName) {
+ this.localName = localName;
+ }
+
+ /**
+ * Method getNamespace.
+ *
+ * @throws OMException
+ */
+ public OMNamespace getNamespace() throws OMException {
+ return ns;
+ }
+
+ /**
+ * Method setNamespace.
+ */
+ public void setNamespace(OMNamespace namespace) {
+ OMNamespace nsObject = null;
+ if (namespace != null) {
+ nsObject = handleNamespace(namespace);
+ }
+ this.ns = nsObject;
+ }
+
+ /**
+ * Method getQName.
+ *
+ * @return Returns QName.
+ */
+ public QName getQName() {
+ QName qName;
+ if (ns != null) {
+ if (ns.getPrefix() != null) {
+ qName = new QName(ns.getName(), localName, ns.getPrefix());
+ } else {
+ qName = new QName(ns.getName(), localName);
+ }
+ } else {
+ qName = new QName(localName);
+ }
+ return qName;
+ }
+
+ public String toStringWithConsume() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ this.serializeAndConsume(baos);
+ return new String(baos.toByteArray());
+ }
+
+ public String toString() {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ try {
+ this.serialize(baos);
+ } catch (XMLStreamException e) {
+ throw new RuntimeException("Can not serialize OM Element " + this.getLocalName(), e);
+ }
+ return new String(baos.toByteArray());
+ }
+
+ /**
+ * Method discard.
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard(this);
+ }
+ }
+
+ /**
+ * Converts a prefix:local qname string into a proper QName, evaluating it
+ * in the OMElement context. Unprefixed qnames resolve to the local namespace.
+ *
+ * @param qname prefixed qname string to resolve
+ * @return Returns null for any failure to extract a qname.
+ */
+ public QName resolveQName(String qname) {
+ ElementHelper helper = new ElementHelper(this);
+ return helper.resolveQName(qname);
+ }
+
+ public OMElement cloneOMElement() {
+ OMElement clonedElement = new StAXOMBuilder(this.getXMLStreamReader(true)).getDocumentElement();
+ clonedElement.build();
+ return clonedElement;
+ }
+
+ public void setLineNumber(int lineNumber) {
+ this.lineNumber = lineNumber;
+ }
+
+ public int getLineNumber() {
+ return lineNumber;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMNamespaceImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMNamespaceImpl.java
new file mode 100644
index 0000000..15571ce
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMNamespaceImpl.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMNamespace;
+
+/**
+ * Class OMNamespaceImpl
+ */
+public class OMNamespaceImpl implements OMNamespace {
+ /**
+ * Field prefix
+ */
+ private String prefix;
+
+ /**
+ * Field uri
+ */
+ private String uri;
+
+ /**
+ * @param uri
+ * @param prefix
+ */
+ public OMNamespaceImpl(String uri, String prefix) {
+ this.uri = uri;
+ this.prefix = prefix;
+ }
+
+ /**
+ * Method equals.
+ *
+ * @param uri
+ * @param prefix
+ * @return Returns boolean.
+ */
+ public boolean equals(String uri, String prefix) {
+ return (((prefix == null) && (this.prefix == null)) ||
+ ((prefix != null) && prefix.equals(this.prefix))) &&
+ uri.equals(uri);
+ }
+
+ /**
+ * Method getPrefix.
+ *
+ * @return Returns String.
+ */
+ public String getPrefix() {
+ return prefix;
+ }
+
+ /**
+ * Method getName.
+ *
+ * @return Returns String.
+ */
+ public String getName() {
+ return uri;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMNavigator.java b/src/org/apache/ws/commons/om/impl/llom/OMNavigator.java
new file mode 100644
index 0000000..d090afb
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMNavigator.java
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNode;
+
+/**
+ * Refer to the testClass to find out how to use
+ * features like isNavigable, isComplete and step.
+ */
+public class OMNavigator {
+ /**
+ * Field node
+ */
+ protected OMNode node;
+
+ /**
+ * Field visited
+ */
+ private boolean visited;
+
+ /**
+ * Field next
+ */
+ private OMNode next;
+
+ // root is the starting element. Once the navigator comes back to the
+ // root, the traversal is terminated
+
+ /**
+ * Field root
+ */
+ private OMNode root;
+
+ /**
+ * Field backtracked
+ */
+ private boolean backtracked;
+
+ // flags that tell the status of the navigator
+
+ /**
+ * Field end
+ */
+ private boolean end = false;
+
+ /**
+ * Field start
+ */
+ private boolean start = true;
+
+ /**
+ * Constructor OMNavigator.
+ */
+ public OMNavigator() {
+ }
+
+ /**
+ * Constructor OMNavigator.
+ *
+ * @param node
+ */
+ public OMNavigator(OMNode node) {
+ init(node);
+ }
+
+ /**
+ * Method init.
+ *
+ * @param node
+ */
+ public void init(OMNode node) {
+ next = node;
+ root = node;
+ backtracked = false;
+ }
+
+ /**
+ * Gets the next node.
+ *
+ * @return Returns OMnode in the sequence of preorder traversal. Note however
+ * that an element node is treated slightly differently. Once the
+ * element is passed it returns the same element in the next encounter as well.
+ */
+ public OMNode next() {
+ if (next == null) {
+ return null;
+ }
+ node = next;
+ visited = backtracked;
+ backtracked = false;
+ updateNextNode();
+
+ // set the starting and ending flags
+ if (root.equals(node)) {
+ if (!start) {
+ end = true;
+ } else {
+ start = false;
+ }
+ }
+ return node;
+ }
+
+ /**
+ * Private method to encapsulate the searching logic.
+ */
+ private void updateNextNode() {
+ if ((next instanceof OMElement) && !visited) {
+ OMElementImpl e = (OMElementImpl) next;
+ if (e.firstChild != null) {
+ next = e.firstChild;
+ } else if (e.isComplete()) {
+ backtracked = true;
+ } else {
+ next = null;
+ }
+ } else {
+ OMNode nextSibling = ((OMNodeImpl) next).nextSibling;
+ //OMNode parent = next.getParent();
+ OMContainer parent = next.getParent();
+ if (nextSibling != null) {
+ next = nextSibling;
+ } else if ((parent != null) && parent.isComplete()) {
+ next = (OMNodeImpl) parent;
+ backtracked = true;
+ } else {
+ next = null;
+ }
+ }
+ }
+
+ /**
+ * Method visited.
+ *
+ * @return Returns boolean.
+ */
+ public boolean visited() {
+ return visited;
+ }
+
+ /**
+ * This is a very special method. This allows the navigator to step
+ * once it has reached the existing OM. At this point the isNavigable
+ * method will return false but the isComplete method may return false
+ * which means that the navigating the given element is not complete and
+ * the navigator cannot proceed.
+ */
+ public void step() {
+ if (!end) {
+ next = node;
+ updateNextNode();
+ }
+ }
+
+ /**
+ * Returns the navigable status.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isNavigable() {
+ if (end) {
+ return false;
+ } else {
+ return !(next == null);
+ }
+ }
+
+ /**
+ * Returns the completed status.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isCompleted() {
+ return end;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMNodeImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMNodeImpl.java
new file mode 100644
index 0000000..e648f91
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMNodeImpl.java
@@ -0,0 +1,378 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMOutputFormat;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMContainerEx;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.OutputStream;
+import java.io.Writer;
+
+/**
+ * Class OMNodeImpl
+ */
+public abstract class OMNodeImpl implements OMNode, OMNodeEx {
+ /**
+ * Field parent
+ */
+ protected OMContainerEx parent;
+
+ /**
+ * Field nextSibling
+ */
+ protected OMNodeImpl nextSibling;
+
+ /**
+ * Field previousSibling
+ */
+ protected OMNodeImpl previousSibling;
+ /**
+ * Field builder
+ */
+ protected OMXMLParserWrapper builder;
+
+ /**
+ * Field done
+ */
+ protected boolean done = false;
+
+ /**
+ * Field nodeType
+ */
+ protected int nodeType;
+
+ /**
+ * Constructor OMNodeImpl
+ */
+ public OMNodeImpl() {
+ }
+
+ /**
+ * For a node to exist there must be a parent.
+ *
+ * @param parent
+ */
+ public OMNodeImpl(OMContainer parent) {
+ if ((parent != null)) {
+ this.parent = (OMContainerEx)parent;
+ parent.addChild(this);
+ }
+ }
+
+ /**
+ * Returns the immediate parent of the node. Parent is always an Element.
+ *
+ * @return Returns OMContainer.
+ *
+ * @throws OMException
+ */
+ public OMContainer getParent() {
+ return parent;
+ }
+
+ /**
+ * Method setParent.
+ *
+ * @param element
+ */
+ public void setParent(OMContainer element) {
+
+ if ((this.parent) == element) {
+ return;
+ }
+
+ //If we are asked to assign a new parent in place
+ //of an existing one. We should detach this node
+ //from the aegis of previous parent.
+ if (this.parent != null) {
+ this.detach();
+ }
+ this.parent = (OMContainerEx)element;
+ }
+
+ /**
+ * Returns the next sibling. This can be an OMAttribute or
+ * OMText or OMElement for others.
+ *
+ * @return Returns OMNode.
+ * @throws org.apache.ws.commons.om.OMException
+ */
+ public OMNode getNextOMSibling() throws OMException {
+ if ((nextSibling == null) && (parent != null) && !parent.isComplete()) {
+ parent.buildNext();
+ }
+ return nextSibling;
+ }
+
+ /**
+ * Method setNextOMSibling.
+ *
+ * @param node
+ */
+ public void setNextOMSibling(OMNode node) {
+ this.nextSibling = (OMNodeImpl) node;
+ }
+
+
+ /**
+ * Indicates whether parser has parsed this information item completely or not.
+ * If some information is not available in the item, one has to check this
+ * attribute to make sure that, this item has been parsed completely or not.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isComplete() {
+ return done;
+ }
+
+ /**
+ * Method setComplete.
+ *
+ * @param state
+ */
+ public void setComplete(boolean state) {
+ this.done = state;
+ }
+
+ /**
+ * Removes this information item and its children, from the model completely.
+ *
+ * @throws OMException
+ */
+ public OMNode detach() throws OMException {
+ if (parent == null) {
+ throw new OMException(
+ "Elements that doesn't have a parent can not be detached");
+ }
+ OMNodeImpl nextSibling = (OMNodeImpl) getNextOMSibling();
+ if (previousSibling == null) {
+ parent.setFirstChild(nextSibling);
+ } else {
+ ((OMNodeEx)getPreviousOMSibling()).setNextOMSibling(nextSibling);
+ }
+ if (nextSibling != null) {
+ nextSibling.setPreviousOMSibling(getPreviousOMSibling());
+ }
+ this.parent = null;
+ return this;
+ }
+
+ /**
+ * Inserts a sibling just after the current information item.
+ *
+ * @param sibling
+ * @throws OMException
+ */
+ public void insertSiblingAfter(OMNode sibling) throws OMException {
+ if (parent == null) {
+ throw new OMException();
+ }
+ ((OMNodeEx)sibling).setParent(parent);
+ if (sibling instanceof OMNodeImpl) {
+ OMNodeImpl siblingImpl = (OMNodeImpl) sibling;
+ if (nextSibling == null) {
+ getNextOMSibling();
+ }
+ siblingImpl.setPreviousOMSibling(this);
+ if (nextSibling != null) {
+ nextSibling.setPreviousOMSibling(sibling);
+ }
+ ((OMNodeEx)sibling).setNextOMSibling(nextSibling);
+ nextSibling = siblingImpl;
+ }
+ }
+
+ /**
+ * Inserts a sibling just before the current information item.
+ *
+ * @param sibling
+ * @throws OMException
+ */
+ public void insertSiblingBefore(OMNode sibling) throws OMException {
+ if (parent == null) {
+ throw new OMException();
+ }
+ if (sibling instanceof OMNodeImpl) {
+ OMNodeImpl siblingImpl = (OMNodeImpl) sibling;
+ siblingImpl.nextSibling = this;
+ if (previousSibling == null) {
+ parent.setFirstChild(siblingImpl);
+ siblingImpl.previousSibling = null;
+ } else {
+ siblingImpl.setParent(parent);
+ previousSibling.setNextOMSibling(siblingImpl);
+ siblingImpl.setPreviousOMSibling(previousSibling);
+ }
+ previousSibling = siblingImpl;
+
+ }
+ }
+
+ /**
+ * Gets the type of node, as this is the super class of all the nodes.
+ *
+ * @return Returns the type of node as indicated by {@link #setType}
+ *
+ * @see #setType
+ */
+ public int getType() {
+ return nodeType;
+ }
+
+ /**
+ * Method setType.
+ *
+ * @param nodeType
+ * @throws OMException
+ */
+ public void setType(int nodeType) throws OMException {
+ this.nodeType = nodeType;
+ }
+
+ /**
+ * Gets the previous sibling.
+ *
+ * @return boolean
+ */
+ public OMNode getPreviousOMSibling() {
+ return previousSibling;
+ }
+
+ /**
+ * Method setPreviousOMSibling.
+ *
+ * @param previousSibling
+ */
+ public void setPreviousOMSibling(OMNode previousSibling) {
+ this.previousSibling = (OMNodeImpl) previousSibling;
+ }
+
+
+ /**
+ * Parses this node and builds the object structure in memory.
+ * However a node, created programmatically, will have done set to true by
+ * default and this will cause populateyourself not to work properly!
+ *
+ * @throws OMException
+ */
+ public void build() throws OMException {
+ while (!done) {
+ builder.next();
+ }
+ }
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param xmlWriter
+ * @throws javax.xml.stream.XMLStreamException
+ *
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(XMLStreamWriter xmlWriter) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(xmlWriter);
+ serialize(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param xmlWriter
+ * @throws javax.xml.stream.XMLStreamException
+ *
+ * @see #serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serializeAndConsume(XMLStreamWriter xmlWriter) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(xmlWriter);
+ serializeAndConsume(omOutput);
+ omOutput.flush();
+ }
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ throw new RuntimeException("Not implemented yet!");
+ }
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serializeAndConsume(OMOutputImpl omOutput) throws XMLStreamException {
+ throw new RuntimeException("Not implemented yet!");
+ }
+
+ public void serialize(OutputStream output) throws XMLStreamException {
+ serialize(XMLOutputFactory.newInstance().createXMLStreamWriter(output));
+ }
+
+ public void serialize(Writer writer) throws XMLStreamException {
+ serialize(XMLOutputFactory.newInstance().createXMLStreamWriter(writer));
+ }
+
+ public void serializeAndConsume(OutputStream output) throws XMLStreamException {
+ serializeAndConsume(XMLOutputFactory.newInstance().createXMLStreamWriter(output));
+ }
+
+ public void serializeAndConsume(Writer writer) throws XMLStreamException {
+ serializeAndConsume(XMLOutputFactory.newInstance().createXMLStreamWriter(writer));
+ }
+
+ public void serialize(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, format);
+ serialize(omOutput);
+ omOutput.flush();
+ }
+
+ public void serialize(Writer writer, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(XMLOutputFactory.newInstance().createXMLStreamWriter(writer));
+ omOutput.setOutputFormat(format);
+ serialize(omOutput);
+ omOutput.flush();
+ }
+
+ public void serializeAndConsume(OutputStream output, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(output, format);
+ serializeAndConsume(omOutput);
+ omOutput.flush();
+ }
+
+ public void serializeAndConsume(Writer writer, OMOutputFormat format) throws XMLStreamException {
+ OMOutputImpl omOutput = new OMOutputImpl(XMLOutputFactory.newInstance().createXMLStreamWriter(writer));
+ omOutput.setOutputFormat(format);
+ serializeAndConsume(omOutput);
+ omOutput.flush();
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMProcessingInstructionImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMProcessingInstructionImpl.java
new file mode 100644
index 0000000..1bb5d35
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMProcessingInstructionImpl.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMProcessingInstruction;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class OMProcessingInstructionImpl extends OMNodeImpl implements OMProcessingInstruction {
+ protected String target;
+ protected String value;
+
+ /**
+ * Constructor OMProcessingInstructionImpl.
+ *
+ * @param parentNode
+ * @param target
+ * @param value
+ */
+ public OMProcessingInstructionImpl(OMContainer parentNode, String target, String value) {
+ super(parentNode);
+ this.target = (target == null) ? null : target.trim();
+ this.value = (value == null) ? null : value.trim();
+ nodeType = OMNode.PI_NODE;
+ }
+
+ /**
+ * Constructor OMProcessingInstructionImpl.
+ *
+ * @param parentNode
+ */
+ public OMProcessingInstructionImpl(OMContainer parentNode) {
+ this(parentNode, null, null);
+ }
+
+ /**
+ * Serializes the node with caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serialize(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ writer.writeProcessingInstruction(this.target+" ", this.value);
+ }
+
+ /**
+ * Serializes the node without caching.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ * @see #serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl)
+ */
+ public void serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ serialize(omOutput);
+ }
+
+ /**
+ * Gets the value of this Processing Instruction.
+ *
+ * @return string
+ */
+ public String getValue() {
+ return value;
+ }
+
+ /**
+ * Sets the target of this Processing Instruction.
+ *
+ * @param target
+ */
+ public void setTarget(String target) {
+ this.target = target;
+ }
+
+ /**
+ * Gets the target of this Processing Instruction.
+ *
+ * @return Returns String.
+ */
+ public String getTarget() {
+ return target;
+ }
+
+ /**
+ * Sets the value of this Processing Instruction.
+ *
+ * @param text
+ */
+ public void setValue(String text) {
+ this.value = text;
+ }
+
+ /**
+ * Discards this node.
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard((OMElement) this.parent);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMSerializerUtil.java b/src/org/apache/ws/commons/om/impl/llom/OMSerializerUtil.java
new file mode 100644
index 0000000..1204a31
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMSerializerUtil.java
@@ -0,0 +1,210 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamingOMSerializer;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.util.Iterator;
+
+public class OMSerializerUtil {
+
+ /**
+ * Method serializeEndpart.
+ *
+ * @param omOutput
+ * @throws javax.xml.stream.XMLStreamException
+ *
+ */
+ public static void serializeEndpart(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ omOutput.getXmlStreamWriter().writeEndElement();
+ }
+
+ /**
+ * Method serializeAttribute.
+ *
+ * @param attr
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public static void serializeAttribute(OMAttribute attr, OMOutputImpl omOutput)
+ throws XMLStreamException {
+
+ // first check whether the attribute is associated with a namespace
+ OMNamespace ns = attr.getNamespace();
+ String prefix = null;
+ String namespaceName = null;
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (ns != null) {
+
+ // add the prefix if it's availble
+ prefix = ns.getPrefix();
+ namespaceName = ns.getName();
+ if (prefix != null) {
+ writer.writeAttribute(prefix, namespaceName,
+ attr.getLocalName(), attr.getAttributeValue());
+ } else {
+ writer.writeAttribute(namespaceName, attr.getLocalName(),
+ attr.getAttributeValue());
+ }
+ } else {
+ writer.writeAttribute(attr.getLocalName(), attr.getAttributeValue());
+ }
+ }
+
+ /**
+ * Method serializeNamespace.
+ *
+ * @param namespace
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public static void serializeNamespace(OMNamespace namespace, org.apache.ws.commons.om.impl.OMOutputImpl omOutput)
+ throws XMLStreamException {
+
+ if (namespace != null) {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ String uri = namespace.getName();
+ String prefix = writer.getPrefix(uri);
+ String ns_prefix = namespace.getPrefix();
+ if (ns_prefix != null && !ns_prefix.equals(prefix)) {
+ writer.writeNamespace(ns_prefix, namespace.getName());
+ }
+ }
+ }
+
+
+ /**
+ * Method serializeStartpart.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public static void serializeStartpart(OMElement element, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ String nameSpaceName = null;
+ String writer_prefix = null;
+ String prefix = null;
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (element.getNamespace() != null) {
+ nameSpaceName = element.getNamespace().getName();
+ writer_prefix = writer.getPrefix(nameSpaceName);
+ prefix = element.getNamespace().getPrefix();
+ if (nameSpaceName != null) {
+ if (writer_prefix != null) {
+ writer.writeStartElement(nameSpaceName,
+ element.getLocalName());
+ } else {
+ prefix = (prefix == null) ? "" : prefix;
+ writer.writeStartElement(prefix, element.getLocalName(),
+ nameSpaceName);
+ writer.writeNamespace(prefix, nameSpaceName);
+ writer.setPrefix(prefix, nameSpaceName);
+ }
+ } else {
+ writer.writeStartElement(element.getLocalName());
+ }
+ } else {
+ writer.writeStartElement(element.getLocalName());
+ // we need to check whether there's a default namespace visible at this point because
+ // otherwise this element will go into that namespace unintentionally. So we check
+ // whether there is a default NS visible and if so turn it off.
+ if (writer.getNamespaceContext().getNamespaceURI("") != null) {
+ writer.writeDefaultNamespace("");
+ }
+ }
+
+ // add the namespaces
+ serializeNamespaces(element, omOutput);
+
+ // add the elements attributes
+ serializeAttributes(element, omOutput);
+ }
+
+ public static void serializeNamespaces(OMElement element,
+ org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ Iterator namespaces = element.getAllDeclaredNamespaces();
+ if (namespaces != null) {
+ while (namespaces.hasNext()) {
+ serializeNamespace((OMNamespace) namespaces.next(), omOutput);
+ }
+ }
+ }
+
+ public static void serializeAttributes(OMElement element,
+ org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ if (element.getAllAttributes() != null) {
+ Iterator attributesList = element.getAllAttributes();
+ while (attributesList.hasNext()) {
+ serializeAttribute((OMAttribute) attributesList.next(),
+ omOutput);
+ }
+ }
+ }
+
+
+ /**
+ * Method serializeNormal.
+ *
+ * @param omOutput
+ * @param cache
+ * @throws XMLStreamException
+ */
+ public static void serializeNormal(OMElement element, OMOutputImpl omOutput, boolean cache)
+ throws XMLStreamException {
+
+ if (cache) {
+ element.build();
+ }
+
+ serializeStartpart(element, omOutput);
+ OMNode firstChild = element.getFirstOMChild();
+ if (firstChild != null) {
+ if (cache) {
+ ((OMNodeEx)firstChild).serialize(omOutput);
+ } else {
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ }
+ }
+ serializeEndpart(omOutput);
+ }
+
+ public static void serializeByPullStream(OMElement element, org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ serializeByPullStream(element, omOutput, false);
+ }
+
+ public static void serializeByPullStream(OMElement element, org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ StreamingOMSerializer streamingOMSerializer = new StreamingOMSerializer();
+ if (cache) {
+ streamingOMSerializer.serialize(element.getXMLStreamReader(),
+ omOutput);
+ } else {
+ XMLStreamReader xmlStreamReaderWithoutCaching = element.getXMLStreamReaderWithoutCaching();
+ streamingOMSerializer.serialize(xmlStreamReaderWithoutCaching,
+ omOutput);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMStAXWrapper.java b/src/org/apache/ws/commons/om/impl/llom/OMStAXWrapper.java
new file mode 100644
index 0000000..62413da
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMStAXWrapper.java
@@ -0,0 +1,1233 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMComment;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.exception.OMStreamingException;
+
+import javax.xml.namespace.NamespaceContext;
+import javax.xml.namespace.QName;
+import javax.xml.stream.Location;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.util.Iterator;
+import java.util.Stack;
+
+/**
+ * Note - This class also implements the streaming constants interface
+ * to get access to the StAX constants
+ */
+public class OMStAXWrapper implements XMLStreamReader, XMLStreamConstants {
+ /**
+ * Field navigator
+ */
+ private OMNavigator navigator;
+
+ /**
+ * Field builder
+ */
+ private OMXMLParserWrapper builder;
+
+ /**
+ * Field parser
+ */
+ private XMLStreamReader parser;
+
+ /**
+ * Field rootNode
+ */
+ private OMNode rootNode;
+
+ /**
+ * Field isFirst
+ */
+ private boolean isFirst = true;
+
+ // Navigable means the output should be taken from the navigator.
+ // As soon as the navigator returns a null navigable will be reset
+ // to false and the subsequent events will be taken from the builder
+ // or the parser directly.
+
+ /**
+ * Field NAVIGABLE
+ */
+ private static final short NAVIGABLE = 0;
+ private static final short SWITCH_AT_NEXT = 1;
+ private static final short COMPLETED = 2;
+ private static final short SWITCHED = 3;
+ private static final short DOCUMENT_COMPLETE = 4;
+
+
+ /**
+ * Field state
+ */
+ private short state;
+
+ /**
+ * Field currentEvent
+ * Default set to START_DOCUMENT
+ */
+ private int currentEvent = START_DOCUMENT;
+
+ // SwitchingAllowed is set to false by default.
+ // This means that unless the user explicitly states
+ // that he wants things not to be cached, everything will
+ // be cached.
+
+ /**
+ * Field switchingAllowed
+ */
+ boolean switchingAllowed = false;
+
+ /**
+ * Field elementStack
+ */
+ private Stack elementStack = new Stack();
+
+ // keeps the next event. The parser actually keeps one step ahead to
+ // detect the end of navigation. (at the end of the stream the navigator
+ // returns a null
+
+ /**
+ * Field nextNode
+ */
+ private OMNode nextNode = null;
+
+ // holder for the current node. Needs this to generate events from the current node
+
+ /**
+ * Field currentNode
+ */
+ private OMNode currentNode = null;
+
+ // needs this to refer to the last known node
+
+ /**
+ * Field lastNode
+ */
+ private OMNode lastNode = null;
+
+ /**
+ * Track depth to ensure we stop generating events when we are done with the root node.
+ */
+ int depth = 0;
+
+ private boolean needToThrowEndDocument = false;
+
+ /**
+ * Method setAllowSwitching.
+ *
+ * @param b
+ */
+ public void setAllowSwitching(boolean b) {
+ this.switchingAllowed = b;
+ }
+
+ /**
+ * Method isAllowSwitching.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isAllowSwitching() {
+ return switchingAllowed;
+ }
+
+ /**
+ * When constructing the OMStaxWrapper, the creator must produce the
+ * builder (an instance of the OMXMLparserWrapper of the input) and the
+ * Element Node to start parsing. The wrapper will parse(proceed) until
+ * the end of the given element. Hence care should be taken to pass the
+ * root element if the entire document is needed.
+ *
+ * @param builder
+ * @param startNode
+ */
+ public OMStAXWrapper(OMXMLParserWrapper builder, OMElement startNode) {
+ this(builder, startNode, false);
+ }
+
+ /**
+ * Constructor OMStAXWrapper.
+ *
+ * @param builder
+ * @param startNode
+ * @param cache
+ */
+ public OMStAXWrapper(OMXMLParserWrapper builder, OMElement startNode,
+ boolean cache) {
+
+ // create a navigator
+ this.navigator = new OMNavigator(startNode);
+ this.builder = builder;
+ this.rootNode = startNode;
+ if (rootNode != null && rootNode.getParent() != null && rootNode.getParent() instanceof OMDocument) {
+ needToThrowEndDocument = true;
+ }
+
+ // initaite the next and current nodes
+ // Note - navigator is written in such a way that it first
+ // returns the starting node at the first call to it
+ currentNode = navigator.next();
+ updateNextNode();
+ switchingAllowed = !cache;
+ }
+
+ /**
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getPrefix()
+ */
+ public String getPrefix() {
+ String returnStr = null;
+ if (parser != null) {
+ returnStr = parser.getPrefix();
+ } else {
+ if ((currentEvent == START_ELEMENT)
+ || (currentEvent == END_ELEMENT)) {
+ OMNamespace ns = ((OMElement) lastNode).getNamespace();
+ returnStr = (ns == null)
+ ? null
+ : ns.getPrefix();
+ }
+ }
+ return returnStr;
+ }
+
+ /**
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getNamespaceURI()
+ */
+ public String getNamespaceURI() {
+ String returnStr = null;
+ if (parser != null) {
+ returnStr = parser.getNamespaceURI();
+ } else {
+ if ((currentEvent == START_ELEMENT)
+ || (currentEvent == END_ELEMENT)
+ || (currentEvent == NAMESPACE)) {
+ OMNamespace ns = ((OMElement) lastNode).getNamespace();
+ returnStr = (ns == null)
+ ? null
+ : ns.getName();
+ }
+ }
+ return returnStr;
+ }
+
+ /**
+ * @return Returns boolean.
+ * @see javax.xml.stream.XMLStreamReader#hasName()
+ */
+ public boolean hasName() {
+ if (parser != null) {
+ return parser.hasName();
+ } else {
+ return ((currentEvent == START_ELEMENT)
+ || (currentEvent == END_ELEMENT));
+ }
+ }
+
+ /**
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getLocalName()
+ */
+ public String getLocalName() {
+ String returnStr = null;
+ if (parser != null) {
+ returnStr = parser.getLocalName();
+ } else {
+ if ((currentEvent == START_ELEMENT)
+ || (currentEvent == END_ELEMENT)
+ || (currentEvent == ENTITY_REFERENCE)) {
+ returnStr = ((OMElement) lastNode).getLocalName();
+ }
+ }
+ return returnStr;
+ }
+
+ /**
+ * @return Returns QName.
+ * @see javax.xml.stream.XMLStreamReader#getName()
+ */
+ public QName getName() {
+ QName returnName = null;
+ if (parser != null) {
+ returnName = parser.getName();
+ } else {
+ if ((currentEvent == START_ELEMENT)
+ || (currentEvent == END_ELEMENT)) {
+ returnName = getQName((OMElement) lastNode);
+ }
+ }
+ return returnName;
+ }
+
+ /**
+ * @return Returns boolean.
+ * @see javax.xml.stream.XMLStreamReader#hasText()
+ */
+ public boolean hasText() {
+ return ((currentEvent == CHARACTERS) || (currentEvent == DTD)
+ || (currentEvent == ENTITY_REFERENCE)
+ || (currentEvent == COMMENT) || (currentEvent == SPACE));
+ }
+
+ /**
+ * @return Returns int.
+ * @see javax.xml.stream.XMLStreamReader#getTextLength()
+ */
+ public int getTextLength() {
+ int returnLength = 0;
+ if (parser != null) {
+ returnLength = parser.getTextLength();
+ } else {
+ OMText textNode = (OMText) lastNode;
+ returnLength = textNode.getText().length();
+ }
+ return returnLength;
+ }
+
+ /**
+ * @return Returns int.
+ * @see javax.xml.stream.XMLStreamReader#getTextStart()
+ */
+ public int getTextStart() {
+ int returnLength = 0;
+ if (parser != null) {
+ returnLength = parser.getTextStart();
+ }
+
+ // Note - this has no relevant method in the OM
+ return returnLength;
+ }
+
+ /**
+ * @param i
+ * @param chars
+ * @param i1
+ * @param i2
+ * @return Returns int.
+ * @throws XMLStreamException
+ * @see javax.xml.stream.XMLStreamReader#getTextCharacters(int, char[], int, int)
+ */
+ public int getTextCharacters(int i, char[] chars, int i1, int i2)
+ throws XMLStreamException {
+ int returnLength = 0;
+ if (parser != null) {
+ try {
+ returnLength = parser.getTextCharacters(i, chars, i1, i2);
+ } catch (XMLStreamException e) {
+ throw new OMStreamingException(e);
+ }
+ } else {
+ if (hasText()) {
+ OMText textNode = (OMText) lastNode;
+ String str = textNode.getText();
+ str.getChars(i, i + i2, chars, i1);
+ }
+ }
+ return returnLength;
+ }
+
+ /**
+ * @return Returns char[].
+ * @see javax.xml.stream.XMLStreamReader#getTextCharacters()
+ */
+ public char[] getTextCharacters() {
+ char[] returnArray = null;
+ if (parser != null) {
+ returnArray = parser.getTextCharacters();
+ } else {
+ if (hasText()) {
+ OMText textNode = (OMText) lastNode;
+ String str = textNode.getText();
+ returnArray = str.toCharArray();
+ }
+ }
+ return returnArray;
+ }
+
+ /**
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getText()
+ */
+ public String getText() {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getText();
+ } else {
+ if (hasText()) {
+ if (lastNode instanceof OMText) {
+ returnString = ((OMText) lastNode).getText();
+ } else if (lastNode instanceof OMComment) {
+ returnString = ((OMComment) lastNode).getValue();
+ }
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @return Returns int.
+ * @see javax.xml.stream.XMLStreamReader#getEventType()
+ */
+
+ // todo this should be improved
+ public int getEventType() {
+ return currentEvent;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getNamespaceURI
+ */
+ public String getNamespaceURI(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getNamespaceURI(i);
+ } else {
+ if (isStartElement() || isEndElement()
+ || (currentEvent == NAMESPACE)) {
+ OMNamespace ns = (OMNamespace) getItemFromIterator(
+ ((OMElement) lastNode).getAllDeclaredNamespaces(), i);
+ returnString = (ns == null)
+ ? null
+ : ns.getName();
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getNamespacePrefix
+ */
+ public String getNamespacePrefix(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getNamespacePrefix(i);
+ } else {
+ if (isStartElement() || isEndElement()
+ || (currentEvent == NAMESPACE)) {
+ OMNamespace ns = (OMNamespace) getItemFromIterator(
+ ((OMElement) lastNode).getAllDeclaredNamespaces(), i);
+ returnString = (ns == null)
+ ? null
+ : ns.getPrefix();
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @return Returns int.
+ * @see javax.xml.stream.XMLStreamReader#getNamespaceCount()
+ */
+ public int getNamespaceCount() {
+ int returnCount = 0;
+ if (parser != null) {
+ returnCount = parser.getNamespaceCount();
+ } else {
+ if (isStartElement() || isEndElement()
+ || (currentEvent == NAMESPACE)) {
+ returnCount =
+ getCount(
+ ((OMElement) lastNode).getAllDeclaredNamespaces());
+ }
+ }
+ return returnCount;
+ }
+
+ /**
+ * @param i
+ * @return Returns boolean.
+ * @see javax.xml.stream.XMLStreamReader#isAttributeSpecified
+ */
+ public boolean isAttributeSpecified(int i) {
+ boolean returnValue = false;
+ if (parser != null) {
+ returnValue = parser.isAttributeSpecified(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+
+ // theres nothing to be returned here
+ } else {
+ throw new IllegalStateException(
+ "attribute type accessed in illegal event!");
+ }
+ }
+ return returnValue;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeValue
+ */
+ public String getAttributeValue(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributeValue(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ OMAttribute attrib = getAttribute((OMElement) lastNode, i);
+ if (attrib != null) {
+ returnString = attrib.getAttributeValue();
+ }
+ } else {
+ throw new IllegalStateException(
+ "attribute type accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeType
+ */
+ public String getAttributeType(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributeType(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+
+ // todo implement this
+ } else {
+ throw new IllegalStateException(
+ "attribute type accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getAttributePrefix
+ */
+ public String getAttributePrefix(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributePrefix(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ OMAttribute attrib = getAttribute((OMElement) lastNode, i);
+ if (attrib != null) {
+ OMNamespace nameSpace = attrib.getNamespace();
+ if (nameSpace != null) {
+ returnString = nameSpace.getPrefix();
+ }
+ }
+ } else {
+ throw new IllegalStateException(
+ "attribute prefix accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeLocalName
+ */
+ public String getAttributeLocalName(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributeLocalName(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ OMAttribute attrib = getAttribute((OMElement) lastNode, i);
+ if (attrib != null) {
+ returnString = attrib.getLocalName();
+ }
+ } else {
+ throw new IllegalStateException(
+ "attribute localName accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns String.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeNamespace
+ */
+ public String getAttributeNamespace(int i) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributeNamespace(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ OMAttribute attrib = getAttribute((OMElement) lastNode, i);
+ if (attrib != null) {
+ OMNamespace nameSpace = attrib.getNamespace();
+ if (nameSpace != null) {
+ returnString = nameSpace.getName();
+ }
+ }
+ } else {
+ throw new IllegalStateException(
+ "attribute nameSpace accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * @param i
+ * @return Returns QName.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeName
+ */
+ public QName getAttributeName(int i) {
+ QName returnQName = null;
+ if (parser != null) {
+ returnQName = parser.getAttributeName(i);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ returnQName = getAttribute((OMElement) lastNode, i).getQName();
+ } else {
+ throw new IllegalStateException(
+ "attribute count accessed in illegal event!");
+ }
+ }
+ return returnQName;
+ }
+
+ /**
+ * @return Returns int.
+ * @see javax.xml.stream.XMLStreamReader#getAttributeCount
+ */
+ public int getAttributeCount() {
+ int returnCount = 0;
+ if (parser != null) {
+ returnCount = parser.getAttributeCount();
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ OMElement elt = (OMElement) lastNode;
+ returnCount = getCount(elt.getAllAttributes());
+ } else {
+ throw new IllegalStateException(
+ "attribute count accessed in illegal event (" +
+ currentEvent + ")!");
+ }
+ }
+ return returnCount;
+ }
+
+ // todo
+
+ /**
+ * Method getAttributeValue.
+ *
+ * @param s
+ * @param s1
+ * @return Returns String.
+ */
+ public String getAttributeValue(String s, String s1) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getAttributeValue(s, s1);
+ } else {
+ if (isStartElement() || (currentEvent == ATTRIBUTE)) {
+ QName qname = new QName(s, s1);
+ OMAttribute attrib = ((OMElement) lastNode).getAttribute(qname);
+ if (attrib != null) {
+ returnString = attrib.getAttributeValue();
+ }
+ } else {
+ throw new IllegalStateException(
+ "attribute type accessed in illegal event!");
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * Method isWhiteSpace.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isWhiteSpace() {
+ boolean b;
+ if (parser != null) {
+ b = parser.isWhiteSpace();
+ } else {
+ b = (currentEvent == SPACE);
+ }
+ return b;
+ }
+
+ /**
+ * Method isCharacters.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isCharacters() {
+ boolean b;
+ if (parser != null) {
+ b = parser.isCharacters();
+ } else {
+ b = (currentEvent == CHARACTERS);
+ }
+ return b;
+ }
+
+ /**
+ * Method isEndElement.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isEndElement() {
+ boolean b;
+ if (parser != null) {
+ b = parser.isEndElement();
+ } else {
+ b = (currentEvent == END_ELEMENT);
+ }
+ return b;
+ }
+
+ /**
+ * @param i
+ * @param s
+ * @param s1
+ * @throws XMLStreamException
+ * @see javax.xml.stream.XMLStreamReader#require(int, String, String)
+ */
+ public void require(int i, String s, String s1) throws XMLStreamException {
+ throw new XMLStreamException();
+ }
+
+ /**
+ * Method isStartElement.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isStartElement() {
+ boolean b;
+ if (parser != null) {
+ b = parser.isStartElement();
+ } else {
+ b = (currentEvent == START_ELEMENT);
+ }
+ return b;
+ }
+
+ /**
+ * Method getNamespaceURI.
+ *
+ * @param s
+ * @return Returns String.
+ */
+ public String getNamespaceURI(String s) {
+ String returnString = null;
+ if (parser != null) {
+ returnString = parser.getNamespaceURI(s);
+ } else {
+ if (isStartElement() || isEndElement()
+ || (currentEvent == NAMESPACE)) {
+
+ // Nothing to do here! How to get the namespacace references
+ }
+ }
+ return returnString;
+ }
+
+ /**
+ * Method close.
+ *
+ * @throws XMLStreamException
+ */
+ public void close() throws XMLStreamException {
+
+ // this doesnot mean anything with respect to the OM
+ if (parser != null) {
+ parser.close();
+ }
+ }
+
+ /**
+ * Method hasNext.
+ *
+ * @return Returns boolean.
+ * @throws XMLStreamException
+ */
+ public boolean hasNext() throws XMLStreamException {
+ if(needToThrowEndDocument){
+ return !(state == DOCUMENT_COMPLETE);
+ } else {
+ return (state != COMPLETED && currentEvent != END_DOCUMENT);
+ }
+ }
+
+ /**
+ * Returns the next tag.
+ *
+ * @return Returns int.
+ * @throws org.apache.ws.commons.om.impl.llom.exception.OMStreamingException
+ *
+ * @throws XMLStreamException
+ */
+ public int nextTag() throws XMLStreamException {
+ int eventType = next();
+ while((eventType == XMLStreamConstants.CHARACTERS && isWhiteSpace()) // skip whitespace
+ || (eventType == XMLStreamConstants.CDATA && isWhiteSpace()) // skip whitespace
+ || eventType == XMLStreamConstants.SPACE
+ || eventType == XMLStreamConstants.PROCESSING_INSTRUCTION
+ || eventType == XMLStreamConstants.COMMENT) {
+ eventType = next();
+ }
+ if (eventType != XMLStreamConstants.START_ELEMENT && eventType != XMLStreamConstants.END_ELEMENT) {
+ throw new XMLStreamException("expected start or end tag", getLocation());
+ }
+ return eventType;
+ }
+
+ /**
+ * @return Returns String.
+ * @throws XMLStreamException
+ * @see javax.xml.stream.XMLStreamReader#getElementText()
+ */
+ public String getElementText() throws XMLStreamException {
+ if (parser != null) {
+ try {
+ return parser.getElementText();
+ } catch (XMLStreamException e) {
+ throw new OMStreamingException(e);
+ }
+ } else {
+ if (currentNode.getType() == OMNode.ELEMENT_NODE) {
+ return ((OMElement)currentNode).getText();
+ }else if (currentNode.getType() == OMNode.TEXT_NODE){
+ return ((OMText)currentNode).getText();
+ }
+ }
+ return "";
+ }
+
+ /**
+ * Method next.
+ *
+ * @return Returns int.
+ * @throws XMLStreamException
+ */
+ public int next() throws XMLStreamException {
+ switch (state) {
+ case DOCUMENT_COMPLETE:
+ throw new XMLStreamException("End of the document reached");
+ case COMPLETED:
+ state = DOCUMENT_COMPLETE;
+ currentEvent = END_DOCUMENT;
+ break;
+ case SWITCH_AT_NEXT:
+ state = SWITCHED;
+
+ // load the parser
+ try {
+ parser = (XMLStreamReader) builder.getParser();
+ } catch (Exception e) {
+ throw new XMLStreamException("problem accessing the parser", e);
+ }
+
+ // We should throw an END_DOCUMENT
+ needToThrowEndDocument = true;
+ if ((currentEvent == START_DOCUMENT) &&
+ (currentEvent == parser.getEventType())) {
+ currentEvent = parser.next();
+ } else {
+ currentEvent = parser.getEventType();
+ }
+
+ if(currentEvent == START_ELEMENT) {
+ depth = 0;
+ } else if(currentEvent == END_ELEMENT) {
+ depth ++;
+ }
+ updateCompleteStatus();
+ break;
+ case NAVIGABLE:
+ currentEvent = generateEvents(currentNode);
+ updateCompleteStatus();
+ updateLastNode();
+ break;
+ case SWITCHED:
+ if(parser.hasNext()) {
+ currentEvent = parser.next();
+ }
+ updateCompleteStatus();
+ break;
+ default :
+ throw new OMStreamingException("unsuppported state!");
+ }
+ return currentEvent;
+ }
+
+ /**
+ * Method getProperty.
+ *
+ * @param s
+ * @return Returns Object.
+ * @throws IllegalArgumentException
+ */
+ public Object getProperty(String s) throws IllegalArgumentException {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * This is a very important method. It keeps the navigator one step ahead
+ * and pushes it one event ahead. If the nextNode is null then navigable is
+ * set to false. At the same time the parser and builder are set up for
+ * the upcoming event generation.
+ *
+ * @throws XMLStreamException
+ */
+ private void updateLastNode() throws XMLStreamException {
+ lastNode = currentNode;
+ currentNode = nextNode;
+ try {
+ updateNextNode();
+ } catch (Exception e) {
+ throw new XMLStreamException(e);
+ }
+ }
+
+ /**
+ * Method updateNextNode.
+ */
+ private void updateNextNode() {
+ if (navigator.isNavigable()) {
+ nextNode = navigator.next();
+ } else {
+ if (!switchingAllowed) {
+ if (navigator.isCompleted()) {
+ nextNode = null;
+
+ } else {
+ builder.next();
+ navigator.step();
+ nextNode = navigator.next();
+ }
+ } else {
+
+ // reset caching (the default is ON so it was not needed in the
+ // earlier case!
+ builder.setCache(false);
+ state = SWITCH_AT_NEXT;
+ }
+ }
+ }
+
+ /**
+ * Method updateCompleteStatus.
+ */
+ private void updateCompleteStatus() {
+ if (state == NAVIGABLE) {
+ if (rootNode == currentNode) {
+ if (isFirst) {
+ isFirst = false;
+ } else {
+ state = COMPLETED;
+ }
+ }
+ } else {
+ if (state == SWITCHED) {
+ if (currentEvent == START_ELEMENT) {
+ ++depth;
+ } else if (currentEvent == END_ELEMENT) {
+ --depth;
+ if(depth < 0) {
+ state = COMPLETED;
+ }
+ }
+ }
+ state = (currentEvent == END_DOCUMENT)
+ ? DOCUMENT_COMPLETE
+ : state;
+ }
+ }
+
+ /**
+ * Method getNamespaceContext.
+ *
+ * @return Returns NamespaceContext.
+ */
+ public NamespaceContext getNamespaceContext() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method getEncoding.
+ *
+ * @return Returns String.
+ */
+ public String getEncoding() {
+ return null;
+ }
+
+ /**
+ * Method getLocation.
+ *
+ * @return Returns Location.
+ */
+ public Location getLocation() {
+ return new EmptyOMLocation();
+ }
+
+ /**
+ * Method getVersion.
+ *
+ * @return Returns String.
+ */
+ public String getVersion() {
+ return "1.0"; //todo put the constant
+ }
+
+
+ /**
+ * Method isStandalone.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isStandalone() {
+ return true;
+ }
+
+ /**
+ * Method standaloneSet.
+ *
+ * @return Returns boolean.
+ */
+ public boolean standaloneSet() {
+ return false;
+ }
+
+ /**
+ * Method getCharacterEncodingScheme.
+ *
+ * @return Returns String.
+ */
+ public String getCharacterEncodingScheme() {
+ return "utf-8";
+ }
+
+ /**
+ * Method getPITarget.
+ *
+ * @return Returns String.
+ */
+ public String getPITarget() {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method getPIData.
+ *
+ * @return Returns String.
+ */
+ public String getPIData() {
+ throw new UnsupportedOperationException();
+ }
+
+ /*
+ *
+ * ################################################################
+ * Generator methods for the OMNodes returned by the navigator
+ * ################################################################
+ *
+ */
+
+ /**
+ * Method generateEvents.
+ *
+ * @param node
+ * @return Returns int.
+ */
+ private int generateEvents(OMNode node) {
+ int returnEvent = 0;
+ int nodeType = node.getType();
+ switch (nodeType) {
+ case OMNode.ELEMENT_NODE:
+ OMElement element = (OMElement) node;
+ returnEvent = generateElementEvents(element);
+ break;
+ case OMNode.TEXT_NODE:
+ returnEvent = generateTextEvents();
+ break;
+ case OMNode.COMMENT_NODE:
+ returnEvent = generateCommentEvents();
+ break;
+ case OMNode.CDATA_SECTION_NODE:
+ returnEvent = generateCdataEvents();
+ break;
+ default :
+ break; // just ignore any other nodes
+ }
+ return returnEvent;
+ }
+
+ /**
+ * Method generateElementEvents.
+ *
+ * @param elt
+ * @return Returns int.
+ */
+ private int generateElementEvents(OMElement elt) {
+ int returnValue = START_ELEMENT;
+ if (!elementStack.isEmpty() && elementStack.peek().equals(elt)) {
+ returnValue = END_ELEMENT;
+ elementStack.pop();
+ } else {
+ elementStack.push(elt);
+ }
+ return returnValue;
+ }
+
+ /**
+ * Method generateTextEvents.
+ *
+ * @return Returns int.
+ */
+ private int generateTextEvents() {
+ return CHARACTERS;
+ }
+
+ /**
+ * Method generateCommentEvents
+ *
+ * @return Returns int.
+ */
+ private int generateCommentEvents() {
+ return COMMENT;
+ }
+
+ /**
+ * Method generateCdataEvents
+ *
+ * @return Returns int.
+ */
+ private int generateCdataEvents() {
+ return CDATA;
+ }
+
+ /*
+ * ####################################################################
+ * Other helper methods
+ * ####################################################################
+ */
+
+ /**
+ * helper method getCount.
+ *
+ * @param it
+ * @return Returns int.
+ */
+ private int getCount(Iterator it) {
+ int count = 0;
+ if (it != null) {
+ while (it.hasNext()) {
+ it.next();
+ count++;
+ }
+ }
+ return count;
+ }
+
+ /**
+ * Helper method getItemFromIterator.
+ *
+ * @param it
+ * @param index
+ * @return Returns Object.
+ */
+ private Object getItemFromIterator(Iterator it, int index) {
+ int count = 0;
+ Object returnObject = null;
+ boolean found = false;
+ if (it != null) {
+ while (it.hasNext()) {
+ returnObject = it.next();
+ if (index == count++) {
+ found = true;
+ break;
+ }
+ }
+ }
+ if (found) {
+ return returnObject;
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Helper method getQName.
+ *
+ * @param element
+ * @return Returns QName.
+ */
+ private QName getQName(OMElement element) {
+ QName returnName;
+ OMNamespace ns = element.getNamespace();
+ String localPart = element.getLocalName();
+ if (ns != null) {
+ String prefix = ns.getPrefix();
+ String uri = ns.getName();
+ if ((prefix == null) || prefix.equals("")) {
+ returnName = new QName(uri, localPart);
+ } else {
+ returnName = new QName(uri, localPart, prefix);
+ }
+ } else {
+ returnName = new QName(localPart);
+ }
+ return returnName;
+ }
+
+ /**
+ * @param elt
+ * @param index
+ * @return Returns OMAttribute.
+ */
+ private OMAttribute getAttribute(OMElement elt, int index) {
+ OMAttribute returnAttrib = null;
+ if (elt != null) {
+ returnAttrib =
+ (OMAttribute) getItemFromIterator(elt.getAllAttributes(),
+ index);
+ }
+ return returnAttrib;
+ }
+
+ public void setParser(XMLStreamReader parser) {
+ this.parser = parser;
+ }
+
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/OMTextImpl.java b/src/org/apache/ws/commons/om/impl/llom/OMTextImpl.java
new file mode 100644
index 0000000..99546fa
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/OMTextImpl.java
@@ -0,0 +1,433 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.util.Base64;
+import org.apache.ws.commons.om.util.UUIDGenerator;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.mtom.MTOMStAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class OMTextImpl extends OMNodeImpl implements OMText, OMConstants {
+ protected String value = null;
+
+ protected String mimeType;
+
+ protected boolean optimize = false;
+
+ protected boolean isBinary = false;
+
+ /**
+ * Field contentID for the mime part used when serializing Binary stuff as
+ * MTOM optimized.
+ */
+ private String contentID = null;
+
+ /**
+ * Field dataHandler contains the DataHandler
+ * Declaring as Object to remove the dependency on
+ * Javax.activation.DataHandler
+ */
+ private Object dataHandlerObject = null;
+
+ /**
+ * Field nameSpace used when serializing Binary stuff as MTOM optimized.
+ */
+ protected OMNamespace ns = new OMNamespaceImpl(
+ "http://www.w3.org/2004/08/xop/include", "xop");
+
+ /**
+ * Field localName used when serializing Binary stuff as MTOM optimized.
+ */
+ protected String localName = "Include";
+
+ /**
+ * Field attributes used when serializing Binary stuff as MTOM optimized.
+ */
+ protected OMAttribute attribute;
+
+ /**
+ * Constructor OMTextImpl.
+ *
+ * @param s
+ */
+ public OMTextImpl(String s) {
+ this.value = s;
+ this.nodeType = TEXT_NODE;
+ }
+
+ /**
+ * @param s
+ * @param nodeType - OMText can handle CHARACTERS, SPACES, CDATA and ENTITY REFERENCES.
+ * Constants for this can be found in OMNode.
+ */
+ public OMTextImpl(String s, int nodeType) {
+ this.value = s;
+ this.nodeType = nodeType;
+ }
+
+ /**
+ * Constructor OMTextImpl.
+ *
+ * @param parent
+ * @param text
+ */
+ public OMTextImpl(OMElement parent, String text) {
+ super(parent);
+ this.value = text;
+ done = true;
+ this.nodeType = TEXT_NODE;
+ }
+
+ public OMTextImpl(OMElement parent, String text, int nodeType) {
+ super(parent);
+ this.value = text;
+ done = true;
+ this.nodeType = nodeType;
+ }
+
+ /**
+ * @param s - base64 encoded String representation of Binary
+ * @param mimeType of the Binary
+ */
+ public OMTextImpl(String s, String mimeType, boolean optimize) {
+ this(null, s, mimeType, optimize);
+ }
+
+ /**
+ * @param parent
+ * @param s -
+ * base64 encoded String representation of Binary
+ * @param mimeType of the Binary
+ */
+ public OMTextImpl(OMElement parent, String s, String mimeType,
+ boolean optimize) {
+ this(parent, s);
+ this.mimeType = mimeType;
+ this.optimize = optimize;
+ this.isBinary = true;
+ done = true;
+ this.nodeType = TEXT_NODE;
+ }
+
+ /**
+ * @param dataHandler To send binary optimised content Created programatically.
+ */
+ public OMTextImpl(Object dataHandler) {
+ this(dataHandler, true);
+ }
+
+ /**
+ * @param dataHandler
+ * @param optimize To send binary content. Created progrmatically.
+ */
+ public OMTextImpl(Object dataHandler, boolean optimize) {
+ this.dataHandlerObject = dataHandler;
+ this.isBinary = true;
+ this.optimize = optimize;
+ done = true;
+ this.nodeType = TEXT_NODE;
+ }
+
+ /**
+ * @param contentID
+ * @param parent
+ * @param builder Used when the builder is encountered with a XOP:Include tag
+ * Stores a reference to the builder and the content-id. Supports
+ * deferred parsing of MIME messages.
+ */
+ public OMTextImpl(String contentID, OMElement parent,
+ OMXMLParserWrapper builder) {
+ super(parent);
+ this.contentID = contentID;
+ this.optimize = true;
+ this.isBinary = true;
+ this.builder = builder;
+ this.nodeType = TEXT_NODE;
+ }
+
+ /**
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public void serialize(OMOutputImpl omOutput) throws XMLStreamException {
+ serializeLocal(omOutput);
+
+ }
+
+ /**
+ * Writes the relevant output.
+ *
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ private void writeOutput(OMOutputImpl omOutput) throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ int type = getType();
+ if (type == TEXT_NODE || type == SPACE_NODE) {
+ writer.writeCharacters(this.getText());
+ } else if (type == CDATA_SECTION_NODE) {
+ writer.writeCData(this.getText());
+ } else if (type == ENTITY_REFERENCE_NODE) {
+ writer.writeEntityRef(this.getText());
+ }
+ }
+
+ /**
+ * Returns the value.
+ */
+ public String getText() throws OMException {
+ if (this.value != null) {
+ return this.value;
+ } else {
+ try {
+ InputStream inStream;
+ inStream = this.getInputStream();
+ byte[] data;
+ StringBuffer text = new StringBuffer();
+ do {
+ data = new byte[1024];
+ int len;
+ while((len = inStream.read(data)) > 0) {
+ byte[] temp = new byte[len];
+ System.arraycopy(data,0,temp,0,len);
+ text.append(Base64.encode(temp));
+ }
+
+ } while (inStream.available() > 0);
+
+ return text.toString();
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+ }
+
+ public boolean isOptimized() {
+ return optimize;
+ }
+
+ public void setOptimize(boolean value) {
+ this.optimize = value;
+ if (value)
+ {
+ isBinary = true;
+ }
+ }
+
+
+ /**
+ * Gets the datahandler.
+ * @return Returns javax.activation.DataHandler
+ */
+ public Object getDataHandler() {
+ /*
+ * this should return a DataHandler containing the binary data
+ * reperesented by the Base64 strings stored in OMText
+ */
+ if (value != null & isBinary) {
+ return org.apache.ws.commons.attachments.DataHandlerUtils.getDataHandlerFromText(value,mimeType);
+ } else {
+
+ if (dataHandlerObject == null) {
+ if (contentID == null) {
+ throw new RuntimeException("ContentID is null");
+ }
+ dataHandlerObject = ((MTOMStAXSOAPModelBuilder) builder)
+ .getDataHandler(contentID);
+ }
+ return dataHandlerObject;
+ }
+ }
+
+ public String getLocalName() {
+ return localName;
+ }
+
+ public java.io.InputStream getInputStream() throws OMException {
+ if (isBinary) {
+ if (dataHandlerObject == null) {
+ getDataHandler();
+ }
+ InputStream inStream;
+ javax.activation.DataHandler dataHandler = (javax.activation.DataHandler)dataHandlerObject;
+ try {
+ inStream = dataHandler.getDataSource().getInputStream();
+ } catch (IOException e) {
+ throw new OMException(
+ "Cannot get InputStream from DataHandler." + e);
+ }
+ return inStream;
+ } else {
+ throw new OMException("Unsupported Operation");
+ }
+ }
+
+ public String getContentID() {
+ if (contentID == null) {
+ contentID = UUIDGenerator.getUUID()
+ + "@apache.org";
+ }
+ return this.contentID;
+ }
+
+ public boolean isComplete() {
+ return done;
+ }
+
+ public void serializeAndConsume(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ serializeLocal(omOutput);
+ }
+
+ private void serializeLocal(OMOutputImpl omOutput) throws XMLStreamException {
+ if (!this.isBinary) {
+ writeOutput(omOutput);
+ } else {
+ if (omOutput.isOptimized()) {
+ if (contentID == null) {
+ contentID = omOutput.getNextContentId();
+ }
+ // send binary as MTOM optimised
+ this.attribute = new OMAttributeImpl("href",
+ new OMNamespaceImpl("", ""), "cid:" + getContentID());
+ this.serializeStartpart(omOutput);
+ omOutput.writeOptimized(this);
+ omOutput.getXmlStreamWriter().writeEndElement();
+ } else {
+ omOutput.getXmlStreamWriter().writeCharacters(this.getText());
+ }
+ }
+ }
+
+ /*
+ * Methods to copy from OMSerialize utils
+ */
+ private void serializeStartpart(OMOutputImpl omOutput)
+ throws XMLStreamException {
+ String nameSpaceName;
+ String writer_prefix;
+ String prefix;
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.ns != null) {
+ nameSpaceName = this.ns.getName();
+ writer_prefix = writer.getPrefix(nameSpaceName);
+ prefix = this.ns.getPrefix();
+ if (nameSpaceName != null) {
+ if (writer_prefix != null) {
+ writer
+ .writeStartElement(nameSpaceName, this
+ .getLocalName());
+ } else {
+ if (prefix != null) {
+ writer.writeStartElement(prefix, this.getLocalName(),
+ nameSpaceName);
+ //TODO FIX ME
+ //writer.writeNamespace(prefix, nameSpaceName);
+ writer.setPrefix(prefix, nameSpaceName);
+ } else {
+ writer.writeStartElement(nameSpaceName, this
+ .getLocalName());
+ writer.writeDefaultNamespace(nameSpaceName);
+ writer.setDefaultNamespace(nameSpaceName);
+ }
+ }
+ } else {
+ writer.writeStartElement(this.getLocalName());
+ }
+ } else {
+ writer.writeStartElement(this.getLocalName());
+ }
+ // add the elements attribute "href"
+ serializeAttribute(this.attribute, omOutput);
+ // add the namespace
+ serializeNamespace(this.ns, omOutput);
+ }
+
+ /**
+ * Method serializeAttribute.
+ *
+ * @param attr
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ static void serializeAttribute(OMAttribute attr, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ // first check whether the attribute is associated with a namespace
+ OMNamespace ns = attr.getNamespace();
+ String prefix;
+ String namespaceName;
+ if (ns != null) {
+ // add the prefix if it's availble
+ prefix = ns.getPrefix();
+ namespaceName = ns.getName();
+ if (prefix != null) {
+ writer.writeAttribute(prefix, namespaceName, attr
+ .getLocalName(), attr.getAttributeValue());
+ } else {
+ writer.writeAttribute(namespaceName, attr.getLocalName(), attr
+ .getAttributeValue());
+ }
+ } else {
+ writer.writeAttribute(attr.getLocalName(), attr.getAttributeValue());
+ }
+ }
+
+ /**
+ * Method serializeNamespace.
+ *
+ * @param namespace
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ static void serializeNamespace(OMNamespace namespace, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (namespace != null) {
+ String uri = namespace.getName();
+ String ns_prefix = namespace.getPrefix();
+ writer.writeNamespace(ns_prefix, namespace.getName());
+ writer.setPrefix(ns_prefix, uri);
+ }
+ }
+
+ /**
+ * A slightly different implementation of the discard method.
+ *
+ * @throws OMException
+ */
+ public void discard() throws OMException {
+ if (done) {
+ this.detach();
+ } else {
+ builder.discard((OMElement) this.parent);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/builder/SAXOMBuilder.java b/src/org/apache/ws/commons/om/impl/llom/builder/SAXOMBuilder.java
new file mode 100644
index 0000000..c41891a
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/builder/SAXOMBuilder.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.xml.sax.Attributes;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.DefaultHandler;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SAXOMBuilder extends DefaultHandler {
+ OMElement root = null;
+
+ OMNode lastNode = null;
+
+ OMElement nextElem = null;
+
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+
+ List prefixMappings = new ArrayList();
+
+ public void setDocumentLocator(Locator arg0) {
+ }
+
+ public void startDocument() throws SAXException {
+
+ }
+
+ public void endDocument() throws SAXException {
+ }
+
+ protected OMElement createNextElement(String localName) throws OMException {
+ OMElement e;
+ if (lastNode == null) {
+ root = e = factory.createOMElement(localName, null, null, null);
+ } else if (lastNode.isComplete()) {
+ e = factory.createOMElement(localName, null, lastNode.getParent(),
+ null);
+ ((OMNodeEx)lastNode).setNextOMSibling(e);
+ ((OMNodeEx)e).setPreviousOMSibling(lastNode);
+ } else {
+ OMElement parent = (OMElement) lastNode;
+ e = factory.createOMElement(localName, null, (OMElement) lastNode,
+ null);
+ parent.setFirstChild(e);
+ }
+ return e;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.xml.sax.ContentHandler#startPrefixMapping(java.lang.String,
+ * java.lang.String)
+ */
+ public void startPrefixMapping(String prefix, String uri)
+ throws SAXException {
+ if (nextElem == null)
+ nextElem = createNextElement(null);
+ nextElem.declareNamespace(uri, prefix);
+ }
+
+ public void endPrefixMapping(String arg0) throws SAXException {
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.xml.sax.ContentHandler#startElement(java.lang.String,
+ * java.lang.String, java.lang.String, org.xml.sax.Attributes)
+ */
+ public void startElement(String namespaceURI, String localName,
+ String qName, Attributes atts) throws SAXException {
+ if (localName == null || localName.trim().equals(""))
+ localName = qName.substring(qName.indexOf(':') + 1);
+ if (nextElem == null)
+ nextElem = createNextElement(localName);
+ else
+ nextElem.setLocalName(localName);
+ nextElem
+ .setNamespace(nextElem.findNamespace(namespaceURI, null));
+ int j = atts.getLength();
+ for (int i = 0; i < j; i++)
+ nextElem.addAttribute(atts.getLocalName(i), atts.getValue(i),
+ nextElem.findNamespace(atts.getURI(i), null));
+ lastNode = nextElem;
+ nextElem = null;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.xml.sax.ContentHandler#endElement(java.lang.String,
+ * java.lang.String, java.lang.String)
+ */
+ public void endElement(String arg0, String arg1, String arg2)
+ throws SAXException {
+ if (lastNode.isComplete()) {
+ OMContainer parent = lastNode.getParent();
+ ((OMNodeEx)parent).setComplete(true);
+ lastNode = (OMNode) parent;
+ } else {
+ OMElement e = (OMElement) lastNode;
+ ((OMNodeEx)e).setComplete(true);
+ }
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.xml.sax.ContentHandler#characters(char[], int, int)
+ */
+ public void characters(char[] ch, int start, int length)
+ throws SAXException {
+ if (lastNode == null) {
+ throw new SAXException("");
+ }
+ OMNode node;
+ if (lastNode.isComplete()) {
+ node =
+ factory.createText((OMElement) lastNode.getParent(),
+ new String(ch,
+ start, length));
+ ((OMNodeEx)lastNode).setNextOMSibling(node);
+ ((OMNodeEx)node).setPreviousOMSibling(lastNode);
+ } else {
+ OMElement e = (OMElement) lastNode;
+ node = factory.createText(e, new String(ch, start, length));
+ e.setFirstChild(node);
+ }
+ lastNode = node;
+ }
+
+ public void ignorableWhitespace(char[] arg0, int arg1, int arg2)
+ throws SAXException {
+ }
+
+ public void processingInstruction(String arg0, String arg1)
+ throws SAXException {
+ }
+
+ public void skippedEntity(String arg0) throws SAXException {
+ }
+
+ /**
+ * @return Returns the root.
+ */
+ public OMElement getRootElement() {
+ return root;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/builder/StAXBuilder.java b/src/org/apache/ws/commons/om/impl/llom/builder/StAXBuilder.java
new file mode 100644
index 0000000..e3136aa
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/builder/StAXBuilder.java
@@ -0,0 +1,424 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamReader;
+
+/**
+ * OM should be able to be built from any data source. And the model it builds
+ * may be a SOAP specific one or just an XML model. This class will give
+ * some common functionality of OM Building from StAX.
+ */
+public abstract class StAXBuilder implements OMXMLParserWrapper {
+
+ /**
+ * Field parser
+ */
+ protected XMLStreamReader parser;
+
+ /**
+ * Field omfactory
+ */
+ protected OMFactory omfactory;
+
+ /**
+ * Field lastNode
+ */
+ protected OMNode lastNode;
+
+ // returns the state of completion
+
+ /**
+ * Field done
+ */
+ protected boolean done = false;
+
+ // keeps the state of the cache
+
+ /**
+ * Field cache
+ */
+ protected boolean cache = true;
+
+ // keeps the state of the parser access. if the parser is
+ // accessed atleast once,this flag will be set
+
+ /**
+ * Field parserAccessed
+ */
+ protected boolean parserAccessed = false;
+ protected OMDocument document;
+
+
+
+ /**
+ * Constructor StAXBuilder.
+ *
+ * @param ombuilderFactory
+ * @param parser
+ */
+ protected StAXBuilder(OMFactory ombuilderFactory, XMLStreamReader parser) {
+ this.parser = parser;
+ omfactory = ombuilderFactory;
+ }
+
+ /**
+ * Constructor StAXBuilder.
+ *
+ * @param parser
+ */
+ protected StAXBuilder(XMLStreamReader parser) {
+ this(OMAbstractFactory.getOMFactory(), parser);
+ }
+
+ /**
+ * Method setOmbuilderFactory.
+ *
+ * @param ombuilderFactory
+ */
+ public void setOmbuilderFactory(OMFactory ombuilderFactory) {
+ this.omfactory = ombuilderFactory;
+ }
+
+ /**
+ * Method processNamespaceData.
+ *
+ * @param node
+ * @param isSOAPElement
+ */
+ protected abstract void processNamespaceData(OMElement node,
+ boolean isSOAPElement);
+
+ // since the behaviors are different when it comes to namespaces
+ // this must be implemented differently
+
+ /**
+ * Method processAttributes.
+ *
+ * @param node
+ */
+ protected void processAttributes(OMElement node) {
+ int attribCount = parser.getAttributeCount();
+ for (int i = 0; i < attribCount; i++) {
+ OMNamespace ns = null;
+ String uri = parser.getAttributeNamespace(i);
+ String prefix = parser.getAttributePrefix(i);
+ if (uri != null && uri.hashCode() != 0) {
+ ns = node.findNamespace(uri, prefix);
+ }
+ // todo if the attributes are supposed to namespace qualified all the time
+ // todo then this should throw an exception here
+ node.addAttribute(parser.getAttributeLocalName(i),
+ parser.getAttributeValue(i), ns);
+ }
+ }
+
+ /**
+ * Method createOMText.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createOMText(int textType) throws OMException {
+ OMNode node = null;
+ if (lastNode == null) {
+ return null;
+ } else if (!lastNode.isComplete()) {
+ node = omfactory.createText((OMElement) lastNode, parser.getText(), textType);
+ } else if (!(lastNode.getParent() instanceof OMDocument)) {
+ node = omfactory.createText((OMElement)lastNode.getParent(), parser.getText(), textType);
+ }
+ return node;
+ }
+
+ /**
+ * Method reset.
+ *
+ * @param node
+ * @throws OMException
+ */
+ public void reset(OMNode node) throws OMException {
+ lastNode = null;
+ }
+
+ /**
+ * Method discard.
+ *
+ * @param el
+ * @throws OMException
+ */
+ public void discard(OMElement el) throws OMException {
+ OMElement element = null;
+
+ if (element.isComplete() || !cache) {
+ throw new OMException();
+ }
+ try {
+ cache = false;
+ do {
+ while (parser.next() != XMLStreamConstants.END_ELEMENT) ;
+
+ // TODO:
+ } while (!parser.getName().equals(element.getQName()));
+ lastNode = element.getPreviousOMSibling();
+ if (lastNode != null) {
+ ((OMNodeEx)lastNode).setNextOMSibling(null);
+ } else {
+ OMElement parent = (OMElement) element.getParent();
+ if (parent == null) {
+ throw new OMException();
+ }
+ parent.setFirstChild(null);
+ lastNode = parent;
+ }
+ cache = true;
+ } catch (OMException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * Method getText.
+ *
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getText() throws OMException {
+ return parser.getText();
+ }
+
+ /**
+ * Method getNamespace.
+ *
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getNamespace() throws OMException {
+ return parser.getNamespaceURI();
+ }
+
+ /**
+ * Method getNamespaceCount.
+ *
+ * @return Returns int.
+ * @throws OMException
+ */
+ public int getNamespaceCount() throws OMException {
+ try {
+ return parser.getNamespaceCount();
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * Method getNamespacePrefix.
+ *
+ * @param index
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getNamespacePrefix(int index) throws OMException {
+ try {
+ return parser.getNamespacePrefix(index);
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * Method getNamespaceUri.
+ *
+ * @param index
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getNamespaceUri(int index) throws OMException {
+ try {
+ return parser.getNamespaceURI(index);
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * Method setCache.
+ *
+ * @param b
+ */
+ public void setCache(boolean b) {
+ if (parserAccessed && b) {
+ throw new UnsupportedOperationException(
+ "parser accessed. cannot set cache");
+ }
+ cache = b;
+ }
+
+ /**
+ * Method getName.
+ *
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getName() throws OMException {
+ return parser.getLocalName();
+ }
+
+ /**
+ * Method getPrefix.
+ *
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getPrefix() throws OMException {
+ return parser.getPrefix();
+ }
+
+ /**
+ * Method getAttributeCount.
+ *
+ * @return Returns int.
+ * @throws OMException
+ */
+ public int getAttributeCount() throws OMException {
+ return parser.getAttributeCount();
+ }
+
+ /**
+ * Method getAttributeNamespace.
+ *
+ * @param arg
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getAttributeNamespace(int arg) throws OMException {
+ return parser.getAttributeNamespace(arg);
+ }
+
+ /**
+ * Method getAttributeName.
+ *
+ * @param arg
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getAttributeName(int arg) throws OMException {
+ return parser.getAttributeNamespace(arg);
+ }
+
+ /**
+ * Method getAttributePrefix.
+ *
+ * @param arg
+ * @return Returns String.
+ * @throws OMException
+ */
+ public String getAttributePrefix(int arg) throws OMException {
+ return parser.getAttributeNamespace(arg);
+ }
+
+ /**
+ * Method getParser.
+ *
+ * @return Returns Object.
+ */
+ public Object getParser() {
+ if (parserAccessed){
+ throw new IllegalStateException(
+ "Parser already accessed!");
+ }
+ if (!cache) {
+ parserAccessed = true;
+ return parser;
+ } else {
+ throw new IllegalStateException(
+ "cache must be switched off to access the parser");
+ }
+ }
+
+ /**
+ * Method isCompleted.
+ *
+ * @return Returns boolean.
+ */
+ public boolean isCompleted() {
+ return done;
+ }
+
+ /**
+ * This method is called with the XMLStreamConstants.START_ELEMENT event.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected abstract OMNode createOMElement() throws OMException;
+
+ /**
+ * Forwards the parser one step further, if parser is not completed yet.
+ * If this is called after parser is done, then throw an OMException.
+ * If the cache is set to false, then returns the event, *without* building the OM tree.
+ * If the cache is set to true, then handles all the events within this, and
+ * builds the object structure appropriately and returns the event.
+ *
+ * @return Returns int.
+ * @throws OMException
+ */
+ public abstract int next() throws OMException;
+
+ /**
+ * @return Returns short.
+ */
+ public short getBuilderType() {
+ return OMConstants.PULL_TYPE_BUILDER;
+ }
+
+ /**
+ * Method registerExternalContentHandler.
+ *
+ * @param obj
+ */
+ public void registerExternalContentHandler(Object obj) {
+ throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method getRegisteredContentHandler.
+ *
+ * @return Returns Object.
+ */
+ public Object getRegisteredContentHandler() {
+ throw new UnsupportedOperationException();
+ }
+
+ public OMDocument getDocument() {
+ return document;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/builder/StAXOMBuilder.java b/src/org/apache/ws/commons/om/impl/llom/builder/StAXOMBuilder.java
new file mode 100644
index 0000000..75901e9
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/builder/StAXOMBuilder.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.OMContainerEx;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+
+
+/**
+ * Constructs an OM without using SOAP specific classes like SOAPEnvelope,
+ * SOAPHeader, SOAPHeaderBlock and SOAPBody. This has the document concept also.
+ */
+public class StAXOMBuilder extends StAXBuilder {
+ /**
+ * Field document
+ */
+
+ private boolean doDebug = false;
+ private static int nsCount = 0;
+
+ /**
+ * Constructor StAXOMBuilder.
+ *
+ * @param ombuilderFactory
+ * @param parser
+ */
+ public StAXOMBuilder(OMFactory ombuilderFactory, XMLStreamReader parser) {
+ super(ombuilderFactory, parser);
+ document = ombuilderFactory.createOMDocument(this);
+ }
+
+ /**
+ * @param filePath - Path to the XML file
+ * @throws XMLStreamException
+ * @throws FileNotFoundException
+ */
+ public StAXOMBuilder(String filePath) throws XMLStreamException, FileNotFoundException {
+ this(XMLInputFactory.newInstance().createXMLStreamReader(new FileInputStream(filePath)));
+ }
+
+ /**
+ * @param inStream - instream which contains the XML
+ * @throws XMLStreamException
+ */
+ public StAXOMBuilder(InputStream inStream) throws XMLStreamException {
+ this(XMLInputFactory.newInstance().createXMLStreamReader(inStream));
+ }
+
+ /**
+ * Constructor StAXOMBuilder.
+ *
+ * @param parser
+ */
+ public StAXOMBuilder(XMLStreamReader parser) {
+ super(parser);
+ omfactory = OMAbstractFactory.getOMFactory();
+ document = omfactory.createOMDocument(this);
+ }
+
+ /**
+ * Method createOMElement.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createOMElement() throws OMException {
+ OMElement node;
+ String elementName = parser.getLocalName();
+ if (lastNode == null) {
+ node = omfactory.createOMElement(elementName, null, document, this);
+ } else if (lastNode.isComplete()) {
+ node = omfactory.createOMElement(elementName, null,
+ lastNode.getParent(), this);
+ ((OMNodeEx) lastNode).setNextOMSibling(node);
+ ((OMNodeEx) node).setPreviousOMSibling(lastNode);
+ } else {
+ OMElement e = (OMElement) lastNode;
+ node = omfactory.createOMElement(elementName, null,
+ (OMElement) lastNode, this);
+ e.setFirstChild(node);
+ }
+ // create the namespaces
+ processNamespaceData(node, false);
+ // fill in the attributes
+ processAttributes(node);
+ node.setLineNumber(parser.getLocation().getLineNumber());
+ return node;
+ }
+
+ /**
+ * Method createOMText.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createComment() throws OMException {
+ OMNode node;
+ if (lastNode == null) {
+ node = omfactory.createOMComment(document, parser.getText());
+ } else if (lastNode.isComplete()) {
+ node = omfactory.createOMComment(lastNode.getParent(), parser.getText());
+ } else {
+ node = omfactory.createOMComment((OMElement) lastNode, parser.getText());
+ }
+ return node;
+ }
+
+ /**
+ * Method createDTD.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createDTD() throws OMException {
+ if (!parser.hasText())
+ return null;
+ return omfactory.createOMDocType(document, parser.getText());
+ }
+
+ /**
+ * Method createPI.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createPI() throws OMException {
+ OMNode node;
+ String target = parser.getPITarget();
+ String data = parser.getPIData();
+ if (lastNode == null) {
+ node = omfactory.createOMProcessingInstruction(document, target, data);
+ } else if (lastNode.isComplete()) {
+ node = omfactory.createOMProcessingInstruction(lastNode.getParent(), target, data);
+ } else if (lastNode instanceof OMText) {
+ node = omfactory.createOMProcessingInstruction(lastNode.getParent(), target, data);
+ } else {
+ node = omfactory.createOMProcessingInstruction((OMContainer) lastNode, target, data);
+ }
+ return node;
+ }
+
+ protected void endElement() {
+ if (lastNode.isComplete()) {
+ OMElement parent = (OMElement) lastNode.getParent();
+ ((OMNodeEx) parent).setComplete(true);
+ lastNode = parent;
+ } else {
+ OMElement e = (OMElement) lastNode;
+ ((OMNodeEx) e).setComplete(true);
+ }
+
+ //return lastNode;
+ }
+
+ /**
+ * Method next.
+ *
+ * @return Returns int.
+ * @throws OMException
+ */
+ public int next() throws OMException {
+ try {
+ if (done) {
+ throw new OMException();
+ }
+ int token = parser.next();
+ if (!cache) {
+ return token;
+ }
+ switch (token) {
+ case XMLStreamConstants.START_ELEMENT:
+ if (doDebug) {
+ System.out.println("START_ELEMENT: " + parser.getName() + ":" + parser.getLocalName());
+ }
+ lastNode = createOMElement();
+ break;
+ case XMLStreamConstants.START_DOCUMENT:
+ // Document has already being created.
+
+ document.setXMLVersion(parser.getVersion());
+ document.setCharsetEncoding(parser.getEncoding());
+ document.setStandalone(parser.isStandalone() ? "yes" : "no");
+ if (doDebug) {
+ System.out.println("START_DOCUMENT: ");
+ }
+ break;
+ case XMLStreamConstants.CHARACTERS:
+ if (doDebug) {
+ System.out.println("CHARACTERS: [" + parser.getText() + "]");
+ }
+ lastNode = createOMText(XMLStreamConstants.CHARACTERS);
+ break;
+ case XMLStreamConstants.CDATA:
+ if (doDebug) {
+ System.out.println("CDATA: [" + parser.getText() + "]");
+ }
+ lastNode = createOMText(XMLStreamConstants.CDATA);
+ break;
+ case XMLStreamConstants.END_ELEMENT:
+ if (doDebug) {
+ System.out.println("END_ELEMENT: " + parser.getName() + ":" + parser.getLocalName());
+ }
+ endElement();
+ break;
+ case XMLStreamConstants.END_DOCUMENT:
+ if (doDebug) {
+ System.out.println("END_DOCUMENT: ");
+ }
+ done = true;
+ ((OMContainerEx) this.document).setComplete(true);
+ break;
+ case XMLStreamConstants.SPACE:
+ if (doDebug) {
+ System.out.println("SPACE: [" + parser.getText() + "]");
+ }
+ lastNode = createOMText(XMLStreamConstants.SPACE);
+ break;
+ case XMLStreamConstants.COMMENT:
+ if (doDebug) {
+ System.out.println("COMMENT: [" + parser.getText() + "]");
+ }
+ createComment();
+ break;
+ case XMLStreamConstants.DTD:
+ if (doDebug) {
+ System.out.println("DTD: [" + parser.getText() + "]");
+ }
+ createDTD();
+ break;
+ case XMLStreamConstants.PROCESSING_INSTRUCTION:
+ if (doDebug) {
+ System.out.println("PROCESSING_INSTRUCTION: [" + parser.getPITarget() + "][" + parser.getPIData() + "]");
+ }
+ createPI();
+ break;
+ case XMLStreamConstants.ENTITY_REFERENCE:
+ if (doDebug) {
+ System.out.println("ENTITY_REFERENCE: " + parser.getLocalName() + "[" + parser.getText() + "]");
+ }
+ lastNode = createOMText(XMLStreamConstants.ENTITY_REFERENCE);
+ break;
+ default :
+ throw new OMException();
+ }
+ return token;
+ } catch (OMException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new OMException(e);
+ }
+ }
+
+ /**
+ * Method getDocumentElement.
+ *
+ * @return Returns root element.
+ */
+ public OMElement getDocumentElement() {
+ return document.getOMDocumentElement();
+ }
+
+ /**
+ * Method processNamespaceData.
+ *
+ * @param node
+ * @param isSOAPElement
+ */
+ protected void processNamespaceData(OMElement node, boolean isSOAPElement) {
+ // set the own namespace
+ String namespaceURI = parser.getNamespaceURI();
+ String prefix = parser.getPrefix();
+
+ OMNamespace namespace = null;
+ if (namespaceURI != null && namespaceURI.length() > 0) {
+
+ // prefix being null means this elements has a default namespace or it has inherited
+ // a default namespace from its parent
+ prefix = prefix == null ? "" : prefix;
+ namespace = node.findNamespace(namespaceURI, prefix);
+
+ if (namespace == null) {
+ namespace = node.declareNamespace(namespaceURI, prefix);
+ }
+ node.setNamespace(namespace);
+ }
+
+
+ int namespaceCount = parser.getNamespaceCount();
+ for (int i = 0; i < namespaceCount; i++) {
+ String nsprefix = parser.getNamespacePrefix(i);
+ nsprefix = (nsprefix == null ? "" : nsprefix);
+
+ //if the namespace is not defined already when we write the start tag declare it
+
+ if (!nsprefix.equals(prefix)) {
+ node.declareNamespace(parser.getNamespaceURI(i),
+ parser.getNamespacePrefix(i));
+ }
+ }
+ }
+
+
+ public void setDoDebug(boolean doDebug) {
+ this.doDebug = doDebug;
+ }
+
+ protected String createPrefix() {
+ return "ns" + nsCount++;
+ }
+
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/exception/OMBuilderException.java b/src/org/apache/ws/commons/om/impl/llom/exception/OMBuilderException.java
new file mode 100644
index 0000000..30e3e52
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/exception/OMBuilderException.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.exception;
+
+import org.apache.ws.commons.om.OMException;
+
+/**
+ * Class OMBuilderException
+ */
+public class OMBuilderException extends OMException {
+
+ private static final long serialVersionUID = -7447667411291193889L;
+
+ /**
+ * Constructor OMBuilderException
+ *
+ * @param s
+ */
+ public OMBuilderException(String s) {
+ super(s);
+ }
+
+ public OMBuilderException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/exception/OMStreamingException.java b/src/org/apache/ws/commons/om/impl/llom/exception/OMStreamingException.java
new file mode 100644
index 0000000..d668817
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/exception/OMStreamingException.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.exception;
+
+import org.apache.ws.commons.om.OMException;
+
+/**
+ * Class OMStreamingException
+ */
+public class OMStreamingException extends OMException {
+
+ private static final long serialVersionUID = 8108888406034145092L;
+
+ /**
+ * Constructor OMStreamingException
+ */
+ public OMStreamingException() {
+ }
+
+ /**
+ * Constructor OMStreamingException
+ *
+ * @param message
+ */
+ public OMStreamingException(String message) {
+ super(message);
+ }
+
+ /**
+ * Constructor OMStreamingException
+ *
+ * @param message
+ * @param cause
+ */
+ public OMStreamingException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ /**
+ * Constructor OMStreamingException
+ *
+ * @param cause
+ */
+ public OMStreamingException(Throwable cause) {
+ super(cause);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/exception/XMLComparisonException.java b/src/org/apache/ws/commons/om/impl/llom/exception/XMLComparisonException.java
new file mode 100644
index 0000000..b3e1117
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/exception/XMLComparisonException.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.exception;
+
+public class XMLComparisonException extends Exception {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ private static final long serialVersionUID = -7918497983548520994L;
+
+ public XMLComparisonException(String message) {
+ super(message);
+ }
+
+ public XMLComparisonException(Throwable cause) {
+ super(cause);
+ }
+
+ public XMLComparisonException(String message, Throwable cause) {
+ super(message, cause);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/factory/OMLinkedListImplFactory.java b/src/org/apache/ws/commons/om/impl/llom/factory/OMLinkedListImplFactory.java
new file mode 100644
index 0000000..055cc14
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/factory/OMLinkedListImplFactory.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.factory;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMComment;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMDocType;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMProcessingInstruction;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMAttributeImpl;
+import org.apache.ws.commons.om.impl.llom.OMCommentImpl;
+import org.apache.ws.commons.om.impl.llom.OMDocTypeImpl;
+import org.apache.ws.commons.om.impl.llom.OMDocumentImpl;
+import org.apache.ws.commons.om.impl.llom.OMElementImpl;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.om.impl.llom.OMProcessingInstructionImpl;
+import org.apache.ws.commons.om.impl.llom.OMTextImpl;
+
+import javax.xml.namespace.QName;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Class OMLinkedListImplFactory
+ */
+public class OMLinkedListImplFactory implements OMFactory {
+
+ private static final String uriAndPrefixSeparator = ";";
+ /**
+ * This is a map of namespaces with the namespace URI as the key and
+ * Namespace object itself as the value.
+ */
+ protected Map namespaceTable = new HashMap(5);
+
+ /**
+ * Method createOMElement.
+ *
+ * @param localName
+ * @param ns
+ * @return Returns OMElement.
+ */
+ public OMElement createOMElement(String localName, OMNamespace ns) {
+ return new OMElementImpl(localName, ns);
+ }
+
+ public OMElement createOMElement(String localName, OMNamespace ns, OMContainer parent) {
+ return new OMElementImpl(localName, ns, parent);
+ }
+
+ /**
+ * Method createOMElement.
+ *
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ * @return Returns OMElement.
+ */
+ public OMElement createOMElement(String localName, OMNamespace ns,
+ OMContainer parent,
+ OMXMLParserWrapper builder) {
+ return new OMElementImpl(localName, ns, parent,
+ builder);
+ }
+
+ /**
+ * Method createOMElement.
+ *
+ * @param localName
+ * @param namespaceURI
+ * @param namespacePrefix
+ * @return Returns OMElement.
+ */
+ public OMElement createOMElement(String localName, String namespaceURI,
+ String namespacePrefix) {
+ return this.createOMElement(localName,
+ this.createOMNamespace(namespaceURI,
+ namespacePrefix));
+ }
+
+ /**
+ * Method createOMElement.
+ *
+ * @param qname
+ * @param parent
+ * @return Returns OMElement.
+ * @throws OMException
+ */
+ public OMElement createOMElement(QName qname, OMContainer parent)
+ throws OMException {
+ return new OMElementImpl(qname, parent);
+ }
+
+ /**
+ * Method createOMNamespace.
+ *
+ * @param uri
+ * @param prefix
+ * @return Returns OMNamespace.
+ */
+ public OMNamespace createOMNamespace(String uri, String prefix) {
+ String key = uri + uriAndPrefixSeparator + prefix;
+ OMNamespace existingNamespaceObject = (OMNamespace) namespaceTable.get(key);
+ if (existingNamespaceObject == null) {
+ existingNamespaceObject = new OMNamespaceImpl(uri, prefix);
+ namespaceTable.put(key, existingNamespaceObject);
+ }
+ return existingNamespaceObject;
+ }
+
+ /**
+ * Method createText.
+ *
+ * @param parent
+ * @param text
+ * @return Returns OMText.
+ */
+ public OMText createText(OMElement parent, String text) {
+ return new OMTextImpl(parent, text);
+ }
+
+ public OMText createText(OMElement parent, String text, int type) {
+ return new OMTextImpl(parent, text, type);
+ }
+
+ /**
+ * Method createText.
+ *
+ * @param s
+ * @return Returns OMText.
+ */
+ public OMText createText(String s) {
+ return new OMTextImpl(s);
+ }
+
+ public OMText createText(String s, int type) {
+ return new OMTextImpl(s, type);
+ }
+
+ /**
+ * Creates text.
+ *
+ * @param s
+ * @param mimeType
+ * @param optimize
+ * @return Returns OMText.
+ */
+ public OMText createText(String s, String mimeType, boolean optimize) {
+ return new OMTextImpl(s, mimeType, optimize);
+ }
+
+ /**
+ * Creates text.
+ *
+ * @param dataHandler
+ * @param optimize
+ * @return Returns OMText.
+ */
+ public OMText createText(Object dataHandler, boolean optimize) {
+ return new OMTextImpl(dataHandler, optimize);
+ }
+
+ public OMText createText(String contentID, OMElement parent,
+ OMXMLParserWrapper builder) {
+ return new OMTextImpl(contentID, parent, builder);
+ }
+
+ /**
+ * Creates text.
+ *
+ * @param parent
+ * @param s
+ * @param mimeType
+ * @param optimize
+ * @return Returns OMText.
+ */
+ public OMText createText(OMElement parent,
+ String s,
+ String mimeType,
+ boolean optimize) {
+ return new OMTextImpl(parent, s, mimeType, optimize);
+ }
+
+ /**
+ * Creates attribute.
+ *
+ * @param localName
+ * @param ns
+ * @param value
+ * @return Returns OMAttribute.
+ */
+ public OMAttribute createOMAttribute(String localName,
+ OMNamespace ns,
+ String value) {
+ return new OMAttributeImpl(localName, ns, value);
+ }
+
+ /**
+ * Creates DocType/DTD.
+ *
+ * @param parent
+ * @param content
+ * @return Returns doctype.
+ */
+ public OMDocType createOMDocType(OMContainer parent, String content) {
+ return new OMDocTypeImpl(parent, content);
+ }
+
+ /**
+ * Creates a PI.
+ *
+ * @param parent
+ * @param piTarget
+ * @param piData
+ * @return Returns OMProcessingInstruction.
+ */
+ public OMProcessingInstruction createOMProcessingInstruction(OMContainer parent, String piTarget, String piData) {
+ return new OMProcessingInstructionImpl(parent, piTarget, piData);
+ }
+
+ /**
+ * Creates a comment.
+ *
+ * @param parent
+ * @param content
+ * @return Returns OMComment.
+ */
+ public OMComment createOMComment(OMContainer parent, String content) {
+ return new OMCommentImpl(parent, content);
+ }
+
+ /* (non-Javadoc)
+ * @see org.apache.ws.commons.om.OMFactory#createOMDocument()
+ */
+ public OMDocument createOMDocument() {
+ return new OMDocumentImpl();
+ }
+
+ /* (non-Javadoc)
+ * @see org.apache.ws.commons.om.OMFactory#createOMDocument(org.apache.ws.commons.om.OMXMLParserWrapper)
+ */
+ public OMDocument createOMDocument(OMXMLParserWrapper builder) {
+ return new OMDocumentImpl(builder);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/factory/OMXMLBuilderFactory.java b/src/org/apache/ws/commons/om/impl/llom/factory/OMXMLBuilderFactory.java
new file mode 100644
index 0000000..c705cc5
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/factory/OMXMLBuilderFactory.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.factory;
+
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLStreamReader;
+
+/**
+ * Class OMXMLBuilderFactory
+ */
+public class OMXMLBuilderFactory {
+ /**
+ * Field PARSER_XPP
+ */
+ public static final String PARSER_XPP = "XPP";
+
+ /**
+ * Field PARSER_STAX
+ */
+ public static final String PARSER_STAX = "StAX";
+
+ /**
+ * Field MODEL_SOAP_SPECIFIC
+ */
+ public static final String MODEL_SOAP_SPECIFIC = "SOAP_SPECIFIC";
+
+ /**
+ * Field MODEL_OM
+ */
+ public static final String MODEL_OM = "OM_ONLY";
+
+ /**
+ * Method createStAXSOAPModelBuilder.
+ *
+ * @param soapFactory
+ * @param parser
+ * @return Returns StAXSOAPModelBuilder.
+ */
+ public static StAXSOAPModelBuilder createStAXSOAPModelBuilder(
+ SOAPFactory soapFactory, XMLStreamReader parser) {
+ return new StAXSOAPModelBuilder(parser, soapFactory, null);
+ }
+
+ /**
+ * Method createStAXOMBuilder.
+ *
+ * @param ombuilderFactory
+ * @param parser
+ * @return Returns StAXOMBuilder.
+ */
+ public static StAXOMBuilder createStAXOMBuilder(OMFactory ombuilderFactory,
+ XMLStreamReader parser) {
+ return new StAXOMBuilder(ombuilderFactory, parser);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilder.java b/src/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilder.java
new file mode 100644
index 0000000..d6f4bd0
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilder.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.mtom;
+
+import org.apache.ws.commons.attachments.MIMEHelper;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.MTOMConstants;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.activation.DataHandler;
+import javax.xml.stream.XMLStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+
+public class MTOMStAXSOAPModelBuilder extends StAXSOAPModelBuilder implements MTOMConstants {
+
+ /**
+ * <code>mimeHelper</code> handles deferred parsing of incoming MIME
+ * Messages.
+ */
+ MIMEHelper mimeHelper;
+
+ int partIndex = 0;
+
+ public MTOMStAXSOAPModelBuilder(XMLStreamReader parser,
+ SOAPFactory factory,
+ MIMEHelper mimeHelper, String soapVersion) {
+ super(parser, factory, soapVersion);
+ this.mimeHelper = mimeHelper;
+ }
+
+ /**
+ * @param reader
+ * @param mimeHelper
+ */
+ public MTOMStAXSOAPModelBuilder(XMLStreamReader reader,
+ MIMEHelper mimeHelper, String soapVersion) {
+ super(reader, soapVersion);
+ this.mimeHelper = mimeHelper;
+ }
+
+ protected OMNode createOMElement() throws OMException {
+
+ elementLevel++;
+ String elementName = parser.getLocalName();
+
+ String namespaceURI = parser.getNamespaceURI();
+
+ // create an OMBlob if the element is an <xop:Include>
+
+ if (XOP_INCLUDE.equalsIgnoreCase(elementName)
+ && XOP_NAMESPACE_URI
+ .equalsIgnoreCase(namespaceURI)) {
+ // do we need to check prfix as well. Meaning, should it be "XOP" ?
+
+
+ OMText node;
+ String contentID = null;
+ String contentIDName = null;
+ if (lastNode == null) {
+ // Decide whether to ckeck the level >3 or not
+ throw new OMException(
+ "XOP:Include element is not supported here");
+ }
+ if (parser.getAttributeCount() > 0) {
+ contentID = parser.getAttributeValue(0);
+ contentID = contentID.trim();
+ contentIDName = parser.getAttributeLocalName(0);
+ if (contentIDName.equalsIgnoreCase("href")
+ & contentID.substring(0, 3).equalsIgnoreCase("cid")) {
+ contentID = contentID.substring(4);
+ String charsetEncoding = getDocument().getCharsetEncoding();
+ String charEnc = charsetEncoding == null || "".equals(charsetEncoding) ? "UTF-8" : charsetEncoding;
+ try {
+ contentID = URLDecoder.decode(contentID, charEnc);
+ } catch (UnsupportedEncodingException e) {
+ throw new OMException("Unsupported Character Encoding Found", e);
+ }
+ } else if (!(contentIDName.equalsIgnoreCase("href")
+ & (!contentID.equals("")))) {
+ throw new OMException(
+ "contentID not Found in XOP:Include element");
+ }
+ } else {
+ throw new OMException(
+ "Href attribute not found in XOP:Include element");
+ }
+
+ // This cannot happen. XOP:Include is always the only child of an parent element
+ // cause it is same as having some text
+ try {
+ OMElement e = (OMElement) lastNode;
+ //node = new OMTextImpl(contentID, (OMElement) lastNode, this);
+ node = this.omfactory.createText(contentID, (OMElement) lastNode, this);
+ e.setFirstChild(node);
+ } catch (ClassCastException e) {
+ throw new OMException(
+ "Last Node & Parent of an OMText should be an Element" +
+ e);
+ }
+
+ return node;
+
+ } else {
+ OMElement node;
+ if (lastNode == null) {
+ node = constructNode(null, elementName, true);
+ setSOAPEnvelope(node);
+ } else if (lastNode.isComplete()) {
+ node =
+ constructNode((OMElement) lastNode.getParent(),
+ elementName,
+ false);
+ ((OMNodeEx)lastNode).setNextOMSibling(node);
+ ((OMNodeEx)node).setPreviousOMSibling(lastNode);
+ } else {
+ OMElement e = (OMElement) lastNode;
+ node = constructNode((OMElement) lastNode, elementName, false);
+ e.setFirstChild(node);
+ }
+
+ // fill in the attributes
+ processAttributes(node);
+ //TODO Exception when trying to log . check this
+ // log.info("Build the OMElelment {" + node.getLocalName() + '}'
+ // + node.getLocalName() + "By the StaxSOAPModelBuilder");
+ return node;
+ }
+ }
+
+ public DataHandler getDataHandler(String blobContentID) throws OMException {
+ return mimeHelper.getDataHandler(blobContentID);
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/serialize/StreamWriterToContentHandlerConverter.java b/src/org/apache/ws/commons/om/impl/llom/serialize/StreamWriterToContentHandlerConverter.java
new file mode 100644
index 0000000..5c00843
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/serialize/StreamWriterToContentHandlerConverter.java
@@ -0,0 +1,234 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.serialize;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.xml.sax.Attributes;
+import org.xml.sax.ContentHandler;
+import org.xml.sax.Locator;
+import org.xml.sax.SAXException;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ * Class StreamWriterToContentHandlerConverter
+ */
+public class StreamWriterToContentHandlerConverter implements ContentHandler {
+ /**
+ * Field log
+ */
+ private Log log = LogFactory.getLog(getClass());
+
+ /**
+ * Field writer
+ */
+ private XMLStreamWriter writer;
+
+ /**
+ * Constructor StreamWriterToContentHandlerConverter.
+ *
+ * @param omOutput
+ */
+ public StreamWriterToContentHandlerConverter(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) {
+ this.writer = omOutput.getXmlStreamWriter();
+ }
+
+ /**
+ * Method endDocument.
+ *
+ * @throws SAXException
+ */
+ public void endDocument() throws SAXException {
+
+ // do nothing
+ }
+
+ /**
+ * Method startDocument.
+ *
+ * @throws SAXException
+ */
+ public void startDocument() throws SAXException {
+
+ //
+ }
+
+ /**
+ * Method characters.
+ *
+ * @param ch
+ * @param start
+ * @param length
+ * @throws SAXException
+ */
+ public void characters(char ch[], int start, int length)
+ throws SAXException {
+ try {
+ writer.writeCharacters(ch, start, length);
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * Method ignorableWhitespace.
+ *
+ * @param ch
+ * @param start
+ * @param length
+ * @throws SAXException
+ */
+ public void ignorableWhitespace(char ch[], int start, int length)
+ throws SAXException {
+
+ // throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method endPrefixMapping.
+ *
+ * @param prefix
+ * @throws SAXException
+ */
+ public void endPrefixMapping(String prefix) throws SAXException {
+
+ // throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method skippedEntity.
+ *
+ * @param name
+ * @throws SAXException
+ */
+ public void skippedEntity(String name) throws SAXException {
+
+ // throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method setDocumentLocator.
+ *
+ * @param locator
+ */
+ public void setDocumentLocator(Locator locator) {
+
+ // throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method processingInstruction.
+ *
+ * @param target
+ * @param data
+ * @throws SAXException
+ */
+ public void processingInstruction(String target, String data)
+ throws SAXException {
+
+ // throw new UnsupportedOperationException();
+ }
+
+ /**
+ * Method startPrefixMapping.
+ *
+ * @param prefix
+ * @param uri
+ * @throws SAXException
+ */
+ public void startPrefixMapping(String prefix, String uri)
+ throws SAXException {
+ try {
+ writer.writeNamespace(prefix, uri);
+ writer.setPrefix(prefix, uri);
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * Method endElement.
+ *
+ * @param namespaceURI
+ * @param localName
+ * @param qName
+ * @throws SAXException
+ */
+ public void endElement(String namespaceURI,
+ String localName,
+ String qName)
+ throws SAXException {
+ try {
+ writer.writeEndElement();
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+
+ /**
+ * Method getPrefix.
+ *
+ * @param qName
+ * @return Returns String.
+ */
+ private String getPrefix(String qName) {
+ if (qName != null) {
+ return qName.substring(0, qName.indexOf(":"));
+ }
+ return null;
+ }
+
+ /**
+ * Method startElement.
+ *
+ * @param namespaceURI
+ * @param localName
+ * @param qName
+ * @param atts
+ * @throws SAXException
+ */
+ public void startElement(String namespaceURI,
+ String localName,
+ String qName,
+ Attributes atts)
+ throws SAXException {
+ try {
+ log.info("writing element {" + namespaceURI + '}' + localName
+ + " directly to stream ");
+ String prefix = getPrefix(qName);
+
+ // it is only the prefix we want to learn from the QName! so we can get rid of the
+ // spliting QName
+ if (prefix == null) {
+ writer.writeStartElement(namespaceURI, localName);
+ } else {
+ writer.writeStartElement(prefix, localName, namespaceURI);
+ }
+ if (atts != null) {
+ int attCount = atts.getLength();
+ for (int i = 0; i < attCount; i++) {
+ writer.writeAttribute(atts.getURI(i), localName,
+ atts.getValue(i));
+ }
+ }
+ } catch (XMLStreamException e) {
+ throw new SAXException(e);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/serialize/StreamingOMSerializer.java b/src/org/apache/ws/commons/om/impl/llom/serialize/StreamingOMSerializer.java
new file mode 100644
index 0000000..d8948cc
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/serialize/StreamingOMSerializer.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.serialize;
+
+import org.apache.ws.commons.om.OMSerializer;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ * Class StreamingOMSerializer
+ */
+public class StreamingOMSerializer implements XMLStreamConstants, OMSerializer {
+
+ /*
+ * The behavior of the serializer is such that it returns when it encounters the
+ * starting element for the second time. The depth variable tracks the depth of the
+ * serilizer and tells it when to return.
+ * Note that it is assumed that this serialization starts on an Element.
+ */
+
+ /**
+ * Field depth
+ */
+ private int depth = 0;
+
+ /**
+ * Method serialize.
+ *
+ * @param node
+ * @param writer
+ * @throws XMLStreamException
+ */
+ public void serialize(XMLStreamReader node, XMLStreamWriter writer)
+ throws XMLStreamException {
+ serializeNode(node, new OMOutputImpl(writer));
+ }
+
+ /**
+ * Method serialize.
+ *
+ * @param obj
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ public void serialize(XMLStreamReader obj, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ XMLStreamReader node = obj;
+ serializeNode(node, omOutput);
+ }
+
+ /**
+ * Method serializeNode.
+ *
+ * @param reader
+ * @param omOutput
+ * @throws XMLStreamException
+ */
+ protected void serializeNode(XMLStreamReader reader, OMOutputImpl omOutput)
+ throws XMLStreamException {
+ //TODO We get the StAXWriter at this point and uses it hereafter assuming that this is the only entry point to this class.
+ // If there can be other classes calling methodes of this we might need to change methode signatures to OMOutputer
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ while (reader.hasNext()) {
+ int event = reader.next();
+ if (event == START_ELEMENT) {
+ serializeElement(reader, writer);
+ depth++;
+ } else if (event == ATTRIBUTE) {
+ serializeAttributes(reader, writer);
+ } else if (event == CHARACTERS) {
+ serializeText(reader, writer);
+ } else if (event == COMMENT) {
+ serializeComment(reader, writer);
+ } else if (event == CDATA) {
+ serializeCData(reader, writer);
+ } else if (event == END_ELEMENT) {
+ serializeEndElement(writer);
+ depth--;
+ } else if (event == END_DOCUMENT) {
+ try {
+ serializeEndElement(writer);
+ } catch (Exception e) {
+ //TODO: log exceptions
+ }
+ }
+ if (depth == 0) {
+ break;
+ }
+ }
+ }
+
+ /**
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeElement(XMLStreamReader reader,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ String prefix = reader.getPrefix();
+ String nameSpaceName = reader.getNamespaceURI();
+ if (nameSpaceName != null) {
+ String writer_prefix = writer.getPrefix(nameSpaceName);
+ if (writer_prefix != null) {
+ writer.writeStartElement(nameSpaceName, reader.getLocalName());
+ } else {
+ if (prefix != null) {
+ writer.writeStartElement(prefix, reader.getLocalName(),
+ nameSpaceName);
+ writer.writeNamespace(prefix, nameSpaceName);
+ writer.setPrefix(prefix, nameSpaceName);
+ } else {
+ writer.writeStartElement(nameSpaceName,
+ reader.getLocalName());
+ writer.writeDefaultNamespace(nameSpaceName);
+ writer.setDefaultNamespace(nameSpaceName);
+ }
+ }
+ } else {
+ writer.writeStartElement(reader.getLocalName());
+ }
+
+ // add attributes
+ serializeAttributes(reader, writer);
+
+ // add the namespaces
+ int count = reader.getNamespaceCount();
+ String namespacePrefix;
+ for (int i = 0; i < count; i++) {
+ namespacePrefix = reader.getNamespacePrefix(i);
+ if(namespacePrefix != null && namespacePrefix.length()==0)
+ continue;
+
+ serializeNamespace(namespacePrefix,
+ reader.getNamespaceURI(i), writer);
+ }
+ }
+
+ /**
+ * Method serializeEndElement.
+ *
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeEndElement(XMLStreamWriter writer)
+ throws XMLStreamException {
+ writer.writeEndElement();
+ }
+
+ /**
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeText(XMLStreamReader reader,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ writer.writeCharacters(reader.getText());
+ }
+
+ /**
+ * Method serializeCData.
+ *
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeCData(XMLStreamReader reader,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ writer.writeCData(reader.getText());
+ }
+
+ /**
+ * Method serializeComment.
+ *
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeComment(XMLStreamReader reader,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ writer.writeComment(reader.getText());
+ }
+
+ /**
+ * @param reader
+ * @param writer
+ * @throws XMLStreamException
+ */
+ protected void serializeAttributes(XMLStreamReader reader,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ int count = reader.getAttributeCount();
+ String prefix = null;
+ String namespaceName = null;
+ for (int i = 0; i < count; i++) {
+ prefix = reader.getAttributePrefix(i);
+ namespaceName = reader.getAttributeNamespace(i);
+ if ((prefix != null) && !namespaceName.equals("")) {
+ writer.writeAttribute(prefix, namespaceName,
+ reader.getAttributeLocalName(i),
+ reader.getAttributeValue(i));
+ } else {
+ writer.writeAttribute(reader.getAttributeLocalName(i),
+ reader.getAttributeValue(i));
+ }
+ }
+ }
+
+ /**
+ * Method serializeNamespace.
+ *
+ * @param prefix
+ * @param URI
+ * @param writer
+ * @throws XMLStreamException
+ */
+ private void serializeNamespace(String prefix,
+ String URI,
+ XMLStreamWriter writer)
+ throws XMLStreamException {
+ String prefix1 = writer.getPrefix(URI);
+ if (prefix1 == null) {
+ writer.writeNamespace(prefix, URI);
+ writer.setPrefix(prefix, URI);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildElementIterator.java b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildElementIterator.java
new file mode 100644
index 0000000..e89379c
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildElementIterator.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.traverse;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+
+import java.util.Iterator;
+
+public class OMChildElementIterator implements Iterator {
+
+ /**
+ * Field currentChild
+ */
+ protected OMNode currentChild;
+
+ /**
+ * Field lastChild
+ */
+ protected OMNode lastChild;
+
+ /**
+ * Field nextCalled
+ */
+ protected boolean nextCalled = false;
+
+ /**
+ * Field removeCalled
+ */
+ protected boolean removeCalled = false;
+
+ /**
+ * Constructor OMChildrenIterator.
+ *
+ * @param currentChild
+ */
+ public OMChildElementIterator(OMElement currentChild) {
+ this.currentChild = currentChild;
+ }
+
+ /**
+ * Removes the last element returned by the iterator (optional operation)
+ * from the underlying collection. This method can be called only once per
+ * call to <tt>next</tt>. The behavior of an iterator is unspecified if
+ * the underlying collection is modified while the iteration is in
+ * progress in any way other than by calling this method.
+ *
+ * @throws UnsupportedOperationException if the <tt>remove</tt>
+ * operation is not supported by this Iterator.
+ * @throws IllegalStateException if the <tt>next</tt> method has not
+ * yet been called, or the <tt>remove</tt> method has already
+ * been called after the last call to the <tt>next</tt>
+ * method.
+ */
+ public void remove() {
+ if (!nextCalled) {
+ throw new IllegalStateException(
+ "next method has not yet being called");
+ }
+ if (removeCalled) {
+ throw new IllegalStateException("remove has already being called");
+ }
+ removeCalled = true;
+
+ // since this acts on the last child there is no need to mess with the current child
+ if (lastChild == null) {
+ throw new OMException("cannot remove a child at this stage!");
+ }
+ lastChild.detach();
+ }
+
+ /**
+ * Returns <tt>true</tt> if the iteration has more elements. (In other
+ * words, returns <tt>true</tt> if <tt>next</tt> would return an element
+ * rather than throwing an exception.)
+ *
+ * @return Returns <tt>true</tt> if the iterator has more elements.
+ */
+ public boolean hasNext() {
+ return (currentChild != null);
+ }
+
+ /**
+ * Returns the next element in the iteration.
+ *
+ * @return Returns the next element in the iteration.
+ * @throws java.util.NoSuchElementException
+ * iteration has no more elements.
+ */
+ public Object next() {
+ nextCalled = true;
+ removeCalled = false;
+
+ if (hasNext()) {
+ lastChild = currentChild;
+ do{
+ currentChild = currentChild.getNextOMSibling();
+ }while(currentChild!=null && currentChild.getType()!=OMNode.ELEMENT_NODE);
+
+
+ return lastChild;
+ }
+ return null;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenIterator.java b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenIterator.java
new file mode 100644
index 0000000..b528b8c
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenIterator.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.traverse;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+
+import java.util.Iterator;
+
+/**
+ * Class OMChildrenIterator
+ */
+public class OMChildrenIterator implements Iterator {
+ /**
+ * Field currentChild
+ */
+ protected OMNode currentChild;
+
+ /**
+ * Field lastChild
+ */
+ protected OMNode lastChild;
+
+ /**
+ * Field nextCalled
+ */
+ protected boolean nextCalled = false;
+
+ /**
+ * Field removeCalled
+ */
+ protected boolean removeCalled = false;
+
+ /**
+ * Constructor OMChildrenIterator.
+ *
+ * @param currentChild
+ */
+ public OMChildrenIterator(OMNode currentChild) {
+ this.currentChild = currentChild;
+ }
+
+ /**
+ * Removes the last element returned by the iterator (optional operation)
+ * from the underlying collection. This method must be called only once per
+ * call to <tt>next</tt>. The behavior of an iterator is unspecified if
+ * the underlying collection is modified while the iteration is in
+ * progress in any way other than by calling this method.
+ *
+ * @throws UnsupportedOperationException if the <tt>remove</tt>
+ * operation is not supported by this Iterator.
+ * @throws IllegalStateException if the <tt>next</tt> method has not
+ * yet been called, or the <tt>remove</tt> method has already
+ * been called after the last call to the <tt>next</tt>
+ * method.
+ */
+ public void remove() {
+ if (!nextCalled) {
+ throw new IllegalStateException(
+ "next method has not yet being called");
+ }
+ if (removeCalled) {
+ throw new IllegalStateException("remove has already being called");
+ }
+ removeCalled = true;
+
+ // since this acts on the last child there is no need to mess with the current child
+ if (lastChild == null) {
+ throw new OMException("cannot remove a child at this stage!");
+ }
+ lastChild.detach();
+ }
+
+ /**
+ * Returns <tt>true</tt> if the iteration has more elements. (In other
+ * words, returns <tt>true</tt> if <tt>next</tt> would return an element
+ * rather than throwing an exception.)
+ *
+ * @return Returns <tt>true</tt> if the iterator has more elements.
+ */
+ public boolean hasNext() {
+ return (currentChild != null);
+ }
+
+ /**
+ * Returns the next element in the iteration.
+ *
+ * @return Returns the next element in the iteration.
+ * @throws java.util.NoSuchElementException
+ * iteration has no more elements.
+ */
+ public Object next() {
+ nextCalled = true;
+ removeCalled = false;
+ if (hasNext()) {
+ lastChild = currentChild;
+ currentChild = currentChild.getNextOMSibling();
+ return lastChild;
+ }
+ return null;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenQNameIterator.java b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenQNameIterator.java
new file mode 100644
index 0000000..ddc8d93
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenQNameIterator.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.traverse;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNode;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Class OMChildrenQNameIterator
+ */
+public class OMChildrenQNameIterator extends OMChildrenIterator {
+ /**
+ * Field givenQName
+ */
+ private QName givenQName;
+
+ /**
+ * Field needToMoveForward
+ */
+ private boolean needToMoveForward = true;
+
+ /**
+ * Field isMatchingNodeFound
+ */
+ private boolean isMatchingNodeFound = false;
+
+ /**
+ * Constructor OMChildrenQNameIterator.
+ *
+ * @param currentChild
+ * @param givenQName
+ */
+ public OMChildrenQNameIterator(OMNode currentChild, QName givenQName) {
+ super(currentChild);
+ this.givenQName = givenQName;
+ }
+
+ /**
+ * Returns <tt>true</tt> if the iteration has more elements. (In other
+ * words, returns <tt>true</tt> if <tt>next</tt> would return an element
+ * rather than throwing an exception.)
+ *
+ * @return Returns <tt>true</tt> if the iterator has more elements.
+ */
+ public boolean hasNext() {
+ while (needToMoveForward) {
+ if (currentChild != null) {
+
+ // check the current node for the criteria
+ if ((currentChild instanceof OMElement)
+ && (isQNamesMatch(
+ ((OMElement) currentChild).getQName(),
+ this.givenQName))) {
+ isMatchingNodeFound = true;
+ needToMoveForward = false;
+ } else {
+
+ // get the next named node
+ currentChild = currentChild.getNextOMSibling();
+ isMatchingNodeFound = needToMoveForward = !(currentChild
+ == null);
+ }
+ } else {
+ needToMoveForward = false;
+ }
+ }
+ return isMatchingNodeFound;
+ }
+
+ /**
+ * Returns the next element in the iteration.
+ *
+ * @return Returns the next element in the iteration.
+ * @throws java.util.NoSuchElementException
+ * iteration has no more elements.
+ */
+ public Object next() {
+
+ // reset the flags
+ needToMoveForward = true;
+ isMatchingNodeFound = false;
+ nextCalled = true;
+ removeCalled = false;
+ lastChild = currentChild;
+ currentChild = currentChild.getNextOMSibling();
+ return lastChild;
+ }
+
+ /**
+ * Cannot use the overridden equals method of QName, as one might want to get
+ * some element just by giving the localname, even though a matching element
+ * has a namespace uri as well.
+ * This is not supported in the equals method of the QName.
+ *
+ * @param elementQName
+ * @param qNameToBeMatched
+ * @return Returns boolean.
+ */
+ private boolean isQNamesMatch(QName elementQName, QName qNameToBeMatched) {
+
+ // if no QName was given, that means user is asking for all
+ if (qNameToBeMatched == null) {
+ return true;
+ }
+
+ // if the given localname is null, whatever value this.qname has, its a match. But can one give a QName without a localName ??
+ boolean localNameMatch =
+ (qNameToBeMatched.getLocalPart() == null)
+ || (qNameToBeMatched.getLocalPart() == "")
+ ||
+ ((elementQName != null)
+ &&
+ elementQName.getLocalPart().equalsIgnoreCase(
+ qNameToBeMatched.getLocalPart()));
+ boolean namespaceURIMatch =
+ (qNameToBeMatched.getNamespaceURI() == null)
+ || (qNameToBeMatched.getNamespaceURI() == "")
+ ||
+ ((elementQName != null)
+ &&
+ elementQName.getNamespaceURI().equalsIgnoreCase(
+ qNameToBeMatched.getNamespaceURI()));
+ return localNameMatch && namespaceURIMatch;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenWithSpecificAttributeIterator.java b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenWithSpecificAttributeIterator.java
new file mode 100644
index 0000000..577985e
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/traverse/OMChildrenWithSpecificAttributeIterator.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.traverse;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNode;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Class OMChildrenWithSpecificAttributeIterator
+ */
+public class OMChildrenWithSpecificAttributeIterator
+ extends OMChildrenIterator {
+ /**
+ * Field attributeName
+ */
+ private QName attributeName;
+
+ /**
+ * Field attributeValue
+ */
+ private String attributeValue;
+
+ /**
+ * Field detach
+ */
+ private boolean detach;
+
+ /**
+ * Constructor OMChildrenWithSpecificAttributeIterator.
+ *
+ * @param currentChild
+ * @param attributeName
+ * @param attributeValue
+ * @param detach
+ */
+ public OMChildrenWithSpecificAttributeIterator(OMNode currentChild,
+ QName attributeName,
+ String attributeValue,
+ boolean detach) {
+ super(currentChild);
+ this.attributeName = attributeName;
+ this.attributeValue = attributeValue;
+ this.detach = detach;
+ }
+
+ /**
+ * Method hasNext.
+ *
+ * @return Returns boolean.
+ */
+ public boolean hasNext() {
+
+ // First check whether we have a child, using the super class
+ if (currentChild == null) {
+ return false;
+ }
+ boolean isMatchingNodeFound = false;
+ boolean needToMoveForward = true;
+
+ // now we have a child to check. If its an OMElement and matches the criteria, then we are done
+ while (needToMoveForward) {
+
+ // check the current node for the criteria
+ if (currentChild instanceof OMElement) {
+ OMAttribute attr =
+ ((OMElement) currentChild).getAttribute(
+ attributeName);
+ if ((attr != null)
+ && attr.getAttributeValue().equalsIgnoreCase(attributeValue)) {
+ isMatchingNodeFound = true;
+ needToMoveForward = false;
+ } else {
+ currentChild = currentChild.getNextOMSibling();
+ needToMoveForward = !(currentChild == null);
+ }
+ } else {
+
+ // get the next named node
+ currentChild = currentChild.getNextOMSibling();
+ needToMoveForward = !(currentChild == null);
+ }
+ }
+ return isMatchingNodeFound;
+ }
+
+ /**
+ * Method next.
+ *
+ * @return Returns Object.
+ */
+ public Object next() {
+ nextCalled = true;
+ removeCalled = false;
+ lastChild = currentChild;
+ currentChild = currentChild.getNextOMSibling();
+ if ((lastChild != null) && detach && lastChild.getParent() != null) {
+ lastChild.detach();
+ }
+ return lastChild;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/impl/llom/util/EmptyIterator.java b/src/org/apache/ws/commons/om/impl/llom/util/EmptyIterator.java
new file mode 100644
index 0000000..7206a8a
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/util/EmptyIterator.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.util;
+
+import java.util.Iterator;
+
+public class EmptyIterator implements Iterator {
+ public void remove() {
+ throw new UnsupportedOperationException();
+
+ }
+
+ public boolean hasNext() {
+ return false;
+ }
+
+ public Object next() {
+ throw new UnsupportedOperationException();
+ }
+}
+
diff --git a/src/org/apache/ws/commons/om/impl/llom/util/XMLComparator.java b/src/org/apache/ws/commons/om/impl/llom/util/XMLComparator.java
new file mode 100644
index 0000000..d697a87
--- /dev/null
+++ b/src/org/apache/ws/commons/om/impl/llom/util/XMLComparator.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.util;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.llom.exception.XMLComparisonException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.Iterator;
+import java.util.Vector;
+
+public class XMLComparator {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ private Log log = LogFactory.getLog(getClass());
+
+ private Vector ignorableNamespaceList = new Vector();
+
+ public void addIgnorableNamespace(String nsURI){
+ ignorableNamespaceList.add(nsURI);
+ }
+
+ public void clearIgnorableNamespaces(){
+ ignorableNamespaceList.clear();
+ }
+
+
+ public boolean compare(OMElement elementOne, OMElement elementTwo) throws XMLComparisonException {
+
+ //ignore if the elements belong to any of the ignorable namespaces list
+ if (isIgnorable(elementOne) ||
+ isIgnorable(elementTwo)){
+ return true;
+ }
+
+ if (elementOne == null && elementTwo == null) {
+ log.info("Both Elements are null.");
+ return true;
+ }
+ if (elementOne == null && elementTwo != null) {
+ throw new XMLComparisonException(
+ "Element One is null and Element Two is not null");
+ }
+ if (elementOne != null && elementTwo == null) {
+ throw new XMLComparisonException(
+ "Element Two is null and Element One is not null");
+ }
+
+ log.info(
+ "Now Checking " + elementOne.getLocalName() + " and " +
+ elementTwo.getLocalName() +
+ "=============================");
+
+ log.info("Comparing Element Names .......");
+ compare("Elements names are not equal. ",
+ elementOne.getLocalName(),
+ elementTwo.getLocalName());
+
+ log.info("Comparing Namespaces .........");
+ compare("Element namespaces are not equal",
+ elementOne.getNamespace(),
+ elementTwo.getNamespace());
+
+ log.info("Comparing attributes .....");
+ compareAllAttributes(elementOne, elementTwo);
+
+ log.info("Comparing texts .....");
+
+ /*
+ * Trimming the value of the XMLElement is not correct
+ * since this compare method cannot be used to compare
+ * element contents with trailing and leading whitespaces
+ * BUT for the practicalltiy of tests and to get the current
+ * tests working we have to trim() the contents
+ */
+ compare("Elements texts are not equal ",
+ elementOne.getText().trim(),
+ elementTwo.getText().trim());
+
+ log.info("Comparing Children ......");
+ compareAllChildren(elementOne, elementTwo);
+
+
+ return true;
+ }
+
+ private void compareAllAttributes(OMElement elementOne,
+ OMElement elementTwo) throws XMLComparisonException {
+ compareAttibutes(elementOne, elementTwo);
+ compareAttibutes(elementTwo, elementOne);
+ }
+
+ private void compareAllChildren(OMElement elementOne,
+ OMElement elementTwo) throws XMLComparisonException {
+ compareChildren(elementOne, elementTwo);
+ compareChildren(elementTwo, elementOne);
+ }
+
+
+ private boolean isIgnorable(OMElement elt){
+ if (elt!=null){
+ OMNamespace namespace = elt.getNamespace();
+ if (namespace!=null){
+ return ignorableNamespaceList.contains(namespace.getName());
+ }else{
+ return false;
+ }
+ }else{
+ return false;
+ }
+ }
+
+
+ private void compareChildren(OMElement elementOne, OMElement elementTwo) throws XMLComparisonException {
+ //ignore if the elements belong to any of the ignorable namespaces list
+ if (isIgnorable(elementOne) ||
+ isIgnorable(elementTwo)){
+ return ;
+ }
+ Iterator elementOneChildren = elementOne.getChildren();
+ while (elementOneChildren.hasNext()) {
+ OMNode omNode = (OMNode) elementOneChildren.next();
+ if (omNode instanceof OMElement) {
+ OMElement elementOneChild = (OMElement) omNode;
+ OMElement elementTwoChild = null;
+ //Do the comparison only if the element is not ignorable
+ if (!isIgnorable(elementOneChild)){
+ elementTwoChild = elementTwo.getFirstChildWithName(
+ elementOneChild.getQName());
+ //Do the comparison only if the element is not ignorable
+ if (!isIgnorable(elementTwoChild)){
+ if (elementTwoChild == null) {
+ throw new XMLComparisonException(
+ " There is no " + elementOneChild.getLocalName() +
+ " element under " +
+ elementTwo.getLocalName());
+ }
+ }
+ }
+ compare(elementOneChild, elementTwoChild);
+ }
+ }
+ }
+
+
+ private void compareAttibutes(OMElement elementOne, OMElement elementTwo) throws XMLComparisonException {
+ int elementOneAtribCount = 0;
+ int elementTwoAtribCount = 0;
+ Iterator attributes = elementOne.getAllAttributes();
+ while (attributes.hasNext()) {
+ OMAttribute omAttribute = (OMAttribute) attributes.next();
+ OMAttribute attr = elementTwo.getAttribute(
+ omAttribute.getQName());
+ if (attr == null) {
+ throw new XMLComparisonException(
+ "Attributes are not the same in two elements. Attribute " +
+ omAttribute.getLocalName() +
+ " != ");
+ }
+ elementOneAtribCount++;
+ }
+
+ Iterator elementTwoIter = elementTwo.getAllAttributes();
+ while (elementTwoIter.hasNext()) {
+ elementTwoIter.next();
+ elementTwoAtribCount++;
+
+ }
+
+ if (elementOneAtribCount != elementTwoAtribCount) {
+ throw new XMLComparisonException(
+ "Attributes are not the same in two elements.");
+ }
+ }
+
+ private void compare(String failureNotice, String one, String two) throws XMLComparisonException {
+ if (!one.equals(two)) {
+ throw new XMLComparisonException(
+ failureNotice + one + " != " + two);
+ }
+ }
+
+ private void compare(String failureNotice,
+ OMNamespace one,
+ OMNamespace two) throws XMLComparisonException {
+ if (one == null && two == null) {
+ return;
+ } else if (one != null && two == null) {
+ throw new XMLComparisonException(
+ "First Namespace is NOT null. But the second is null");
+ } else if (one == null && two != null) {
+ throw new XMLComparisonException(
+ "First Namespace is null. But the second is NOT null");
+ }
+
+ if (!one.getName().equals(two.getName())) {
+ throw new XMLComparisonException(
+ failureNotice + one + " != " + two);
+ }
+
+ // Do we need to compare prefixes as well
+ }
+}
diff --git a/src/org/apache/ws/commons/om/util/Base64.java b/src/org/apache/ws/commons/om/util/Base64.java
new file mode 100644
index 0000000..d240b83
--- /dev/null
+++ b/src/org/apache/ws/commons/om/util/Base64.java
@@ -0,0 +1,295 @@
+package org.apache.ws.commons.om.util;
+
+import java.io.OutputStream;
+import java.io.IOException;
+import java.io.Writer;
+
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ *
+ */
+
+public class Base64 {
+ private static final char[] S_BASE64CHAR = {'A', 'B', 'C', 'D', 'E', 'F',
+ 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
+ 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+ 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
+ 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
+ '6', '7', '8', '9', '+', '/'};
+
+ private static final char S_BASE64PAD = '=';
+
+ private static final byte[] S_DECODETABLE = new byte[128];
+
+ static {
+ for (int i = 0; i < S_DECODETABLE.length; i++)
+ S_DECODETABLE[i] = Byte.MAX_VALUE; // 127
+ for (int i = 0; i < S_BASE64CHAR.length; i++)
+ // 0 to 63
+ S_DECODETABLE[S_BASE64CHAR[i]] = (byte) i;
+ }
+
+ private static int decode0(char[] ibuf, byte[] obuf, int wp) {
+ int outlen = 3;
+ if (ibuf[3] == S_BASE64PAD)
+ outlen = 2;
+ if (ibuf[2] == S_BASE64PAD)
+ outlen = 1;
+ int b0 = S_DECODETABLE[ibuf[0]];
+ int b1 = S_DECODETABLE[ibuf[1]];
+ int b2 = S_DECODETABLE[ibuf[2]];
+ int b3 = S_DECODETABLE[ibuf[3]];
+ switch (outlen) {
+ case 1:
+ obuf[wp] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ return 1;
+ case 2:
+ obuf[wp++] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ obuf[wp] = (byte) (b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
+ return 2;
+ case 3:
+ obuf[wp++] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);
+ obuf[wp++] = (byte) (b1 << 4 & 0xf0 | b2 >> 2 & 0xf);
+ obuf[wp] = (byte) (b2 << 6 & 0xc0 | b3 & 0x3f);
+ return 3;
+ default:
+ throw new RuntimeException("internalError00");
+ }
+ }
+
+ /**
+ *
+ */
+ public static byte[] decode(char[] data, int off, int len) {
+ char[] ibuf = new char[4];
+ int ibufcount = 0;
+ byte[] obuf = new byte[len / 4 * 3 + 3];
+ int obufcount = 0;
+ for (int i = off; i < off + len; i++) {
+ char ch = data[i];
+ if (ch == S_BASE64PAD || ch < S_DECODETABLE.length
+ && S_DECODETABLE[ch] != Byte.MAX_VALUE) {
+ ibuf[ibufcount++] = ch;
+ if (ibufcount == ibuf.length) {
+ ibufcount = 0;
+ obufcount += decode0(ibuf, obuf, obufcount);
+ }
+ }
+ }
+ if (obufcount == obuf.length)
+ return obuf;
+ byte[] ret = new byte[obufcount];
+ System.arraycopy(obuf, 0, ret, 0, obufcount);
+ return ret;
+ }
+
+ /**
+ *
+ */
+ public static byte[] decode(String data) {
+ char[] ibuf = new char[4];
+ int ibufcount = 0;
+ byte[] obuf = new byte[data.length() / 4 * 3 + 3];
+ int obufcount = 0;
+ for (int i = 0; i < data.length(); i++) {
+ char ch = data.charAt(i);
+ if (ch == S_BASE64PAD || ch < S_DECODETABLE.length
+ && S_DECODETABLE[ch] != Byte.MAX_VALUE) {
+ ibuf[ibufcount++] = ch;
+ if (ibufcount == ibuf.length) {
+ ibufcount = 0;
+ obufcount += decode0(ibuf, obuf, obufcount);
+ }
+ }
+ }
+ if (obufcount == obuf.length)
+ return obuf;
+ byte[] ret = new byte[obufcount];
+ System.arraycopy(obuf, 0, ret, 0, obufcount);
+ return ret;
+ }
+
+ /**
+ *
+ */
+ public static void decode(char[] data, int off, int len,
+ OutputStream ostream) throws IOException {
+ char[] ibuf = new char[4];
+ int ibufcount = 0;
+ byte[] obuf = new byte[3];
+ for (int i = off; i < off + len; i++) {
+ char ch = data[i];
+ if (ch == S_BASE64PAD || ch < S_DECODETABLE.length
+ && S_DECODETABLE[ch] != Byte.MAX_VALUE) {
+ ibuf[ibufcount++] = ch;
+ if (ibufcount == ibuf.length) {
+ ibufcount = 0;
+ int obufcount = decode0(ibuf, obuf, 0);
+ ostream.write(obuf, 0, obufcount);
+ }
+ }
+ }
+ }
+
+ /**
+ *
+ */
+ public static void decode(String data, OutputStream ostream)
+ throws IOException {
+ char[] ibuf = new char[4];
+ int ibufcount = 0;
+ byte[] obuf = new byte[3];
+ for (int i = 0; i < data.length(); i++) {
+ char ch = data.charAt(i);
+ if (ch == S_BASE64PAD || ch < S_DECODETABLE.length
+ && S_DECODETABLE[ch] != Byte.MAX_VALUE) {
+ ibuf[ibufcount++] = ch;
+ if (ibufcount == ibuf.length) {
+ ibufcount = 0;
+ int obufcount = decode0(ibuf, obuf, 0);
+ ostream.write(obuf, 0, obufcount);
+ }
+ }
+ }
+ }
+
+ /**
+ * Returns base64 representation of specified byte array.
+ */
+ public static String encode(byte[] data) {
+ return encode(data, 0, data.length);
+ }
+
+ /**
+ * Returns base64 representation of specified byte array.
+ */
+ public static String encode(byte[] data, int off, int len) {
+ if (len <= 0)
+ return "";
+ char[] out = new char[len / 3 * 4 + 4];
+ int rindex = off;
+ int windex = 0;
+ int rest = len - off;
+ while (rest >= 3) {
+ int i = ((data[rindex] & 0xff) << 16)
+ + ((data[rindex + 1] & 0xff) << 8)
+ + (data[rindex + 2] & 0xff);
+ out[windex++] = S_BASE64CHAR[i >> 18];
+ out[windex++] = S_BASE64CHAR[(i >> 12) & 0x3f];
+ out[windex++] = S_BASE64CHAR[(i >> 6) & 0x3f];
+ out[windex++] = S_BASE64CHAR[i & 0x3f];
+ rindex += 3;
+ rest -= 3;
+ }
+ if (rest == 1) {
+ int i = data[rindex] & 0xff;
+ out[windex++] = S_BASE64CHAR[i >> 2];
+ out[windex++] = S_BASE64CHAR[(i << 4) & 0x3f];
+ out[windex++] = S_BASE64PAD;
+ out[windex++] = S_BASE64PAD;
+ } else if (rest == 2) {
+ int i = ((data[rindex] & 0xff) << 8) + (data[rindex + 1] & 0xff);
+ out[windex++] = S_BASE64CHAR[i >> 10];
+ out[windex++] = S_BASE64CHAR[(i >> 4) & 0x3f];
+ out[windex++] = S_BASE64CHAR[(i << 2) & 0x3f];
+ out[windex++] = S_BASE64PAD;
+ }
+ return new String(out, 0, windex);
+ }
+
+ /**
+ * Outputs base64 representation of the specified byte array to a byte
+ * stream.
+ */
+ public static void encode(byte[] data, int off, int len,
+ OutputStream ostream) throws IOException {
+ if (len <= 0)
+ return;
+ byte[] out = new byte[4];
+ int rindex = off;
+ int rest = len - off;
+ while (rest >= 3) {
+ int i = ((data[rindex] & 0xff) << 16)
+ + ((data[rindex + 1] & 0xff) << 8)
+ + (data[rindex + 2] & 0xff);
+ out[0] = (byte) S_BASE64CHAR[i >> 18];
+ out[1] = (byte) S_BASE64CHAR[(i >> 12) & 0x3f];
+ out[2] = (byte) S_BASE64CHAR[(i >> 6) & 0x3f];
+ out[3] = (byte) S_BASE64CHAR[i & 0x3f];
+ ostream.write(out, 0, 4);
+ rindex += 3;
+ rest -= 3;
+ }
+ if (rest == 1) {
+ int i = data[rindex] & 0xff;
+ out[0] = (byte) S_BASE64CHAR[i >> 2];
+ out[1] = (byte) S_BASE64CHAR[(i << 4) & 0x3f];
+ out[2] = (byte) S_BASE64PAD;
+ out[3] = (byte) S_BASE64PAD;
+ ostream.write(out, 0, 4);
+ } else if (rest == 2) {
+ int i = ((data[rindex] & 0xff) << 8) + (data[rindex + 1] & 0xff);
+ out[0] = (byte) S_BASE64CHAR[i >> 10];
+ out[1] = (byte) S_BASE64CHAR[(i >> 4) & 0x3f];
+ out[2] = (byte) S_BASE64CHAR[(i << 2) & 0x3f];
+ out[3] = (byte) S_BASE64PAD;
+ ostream.write(out, 0, 4);
+ }
+ }
+
+ /**
+ * Outputs base64 representation of the specified byte array to a character
+ * stream.
+ */
+ public static void encode(byte[] data, int off, int len, Writer writer)
+ throws IOException {
+ if (len <= 0)
+ return;
+ char[] out = new char[4];
+ int rindex = off;
+ int rest = len - off;
+ int output = 0;
+ while (rest >= 3) {
+ int i = ((data[rindex] & 0xff) << 16)
+ + ((data[rindex + 1] & 0xff) << 8)
+ + (data[rindex + 2] & 0xff);
+ out[0] = S_BASE64CHAR[i >> 18];
+ out[1] = S_BASE64CHAR[(i >> 12) & 0x3f];
+ out[2] = S_BASE64CHAR[(i >> 6) & 0x3f];
+ out[3] = S_BASE64CHAR[i & 0x3f];
+ writer.write(out, 0, 4);
+ rindex += 3;
+ rest -= 3;
+ output += 4;
+ if (output % 76 == 0)
+ writer.write("\n");
+ }
+ if (rest == 1) {
+ int i = data[rindex] & 0xff;
+ out[0] = S_BASE64CHAR[i >> 2];
+ out[1] = S_BASE64CHAR[(i << 4) & 0x3f];
+ out[2] = S_BASE64PAD;
+ out[3] = S_BASE64PAD;
+ writer.write(out, 0, 4);
+ } else if (rest == 2) {
+ int i = ((data[rindex] & 0xff) << 8) + (data[rindex + 1] & 0xff);
+ out[0] = S_BASE64CHAR[i >> 10];
+ out[1] = S_BASE64CHAR[(i >> 4) & 0x3f];
+ out[2] = S_BASE64CHAR[(i << 2) & 0x3f];
+ out[3] = S_BASE64PAD;
+ writer.write(out, 0, 4);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/om/util/ElementHelper.java b/src/org/apache/ws/commons/om/util/ElementHelper.java
new file mode 100644
index 0000000..8ddb306
--- /dev/null
+++ b/src/org/apache/ws/commons/om/util/ElementHelper.java
@@ -0,0 +1,108 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.util;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+/**
+ * Helper class to provide extra utility stuff against elements.
+ * The code is designed to work with any element implementation.
+ */
+
+public class ElementHelper {
+
+ private OMElement element;
+
+ /**
+ * Constructs and binds to an element.
+ * @param element element to work with
+ */
+ public ElementHelper(OMElement element) {
+ this.element = element;
+ }
+
+ /**
+ * Turns a prefix:local qname string into a proper QName, evaluating it in the OMElement context.
+ *
+ * @param qname qname to resolve
+ * @param defaultToParentNameSpace flag that controls behaviour when there is no namespace.
+ * @return Returns null for any failure to extract a qname.
+ */
+ public QName resolveQName(String qname, boolean defaultToParentNameSpace) {
+ int colon = qname.indexOf(':');
+ if (colon < 0) {
+ if (defaultToParentNameSpace) {
+ //get the parent ns and use it for the child
+ OMNamespace namespace = element.getNamespace();
+ return new QName(namespace.getName(), qname, namespace.getPrefix());
+ } else {
+ //else things without no prefix are local.
+ return new QName(qname);
+ }
+ }
+ String prefix = qname.substring(0, colon);
+ String local = qname.substring(colon + 1);
+ if (local.length() == 0) {
+ //empy local, exit accordingly
+ return null;
+ }
+
+ OMNamespace namespace = element.findNamespaceURI(prefix);
+ if (namespace == null) {
+ return null;
+ }
+ return new QName(namespace.getName(), local, prefix);
+ }
+
+ /**
+ * Turns a prefix:local qname string into a proper QName, evaluating it in the OMElement context.
+ * Unprefixed qnames resolve to the local namespace.
+ *
+ * @param qname prefixed qname string to resolve
+ * @return Returns null for any failure to extract a qname.
+ */
+ public QName resolveQName(String qname) {
+ return resolveQName(qname, true);
+ }
+
+ public static void setNewElement(OMElement parent,
+ OMElement myElement,
+ OMElement newElement) {
+ if (myElement != null) {
+ myElement.discard();
+ }
+ parent.addChild(newElement);
+ myElement = newElement;
+ }
+
+ public static OMElement getChildWithName(OMElement parent,
+ String childName) {
+ Iterator childrenIter = parent.getChildren();
+ while (childrenIter.hasNext()) {
+ OMNode node = (OMNode) childrenIter.next();
+ if (node.getType() == OMNode.ELEMENT_NODE &&
+ childName.equals(((OMElement) node).getLocalName())) {
+ return (OMElement) node;
+ }
+ }
+ return null;
+ }
+}
diff --git a/src/org/apache/ws/commons/om/util/UUIDGenerator.java b/src/org/apache/ws/commons/om/util/UUIDGenerator.java
new file mode 100644
index 0000000..f3c95d6
--- /dev/null
+++ b/src/org/apache/ws/commons/om/util/UUIDGenerator.java
@@ -0,0 +1,104 @@
+package org.apache.ws.commons.om.util;
+
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ *
+ */
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Date;
+import java.util.Random;
+
+public class UUIDGenerator {
+ /**
+ * This class will give UUIDs for axis2.
+ */
+
+ private static String baseUUID = null;
+ private static long incrementingValue = 0;
+
+
+ private static Random myRand = null;
+
+ /**
+ * MD5 a random string with localhost/date etc will return 128 bits
+ * construct a string of 18 characters from those bits.
+ *
+ * @return string
+ */
+ public static String getUUID() {
+ if (baseUUID == null) {
+ baseUUID = getInitialUUID();
+ }
+ if (++incrementingValue >= Long.MAX_VALUE) {
+ incrementingValue = 0;
+ }
+ return "urn:uuid:" + baseUUID + new Date().getTime() + incrementingValue;
+ }
+
+ protected static String getInitialUUID() {
+ if (myRand == null) {
+ myRand = new Random();
+ }
+ long rand = myRand.nextLong();
+ String sid;
+ try {
+ sid = InetAddress.getLocalHost().toString();
+ } catch (UnknownHostException e) {
+ sid = Thread.currentThread().getName();
+ }
+ StringBuffer sb = new StringBuffer();
+ sb.append(sid);
+ sb.append(":");
+ sb.append(Long.toString(rand));
+ MessageDigest md5 = null;
+ try {
+ md5 = MessageDigest.getInstance("MD5");
+ } catch (NoSuchAlgorithmException e) {
+ //System.out.println("Error: " + e);
+ //todo heve to be properly handle
+ }
+ md5.update(sb.toString().getBytes());
+ byte[] array = md5.digest();
+ StringBuffer sb2 = new StringBuffer();
+ for (int j = 0; j < array.length; ++j) {
+ int b = array[j] & 0xFF;
+ sb2.append(Integer.toHexString(b));
+ }
+ int begin = myRand.nextInt();
+ if (begin < 0) begin = begin * -1;
+ begin = begin % 8;
+ return sb2.toString().substring(begin, begin + 18).toUpperCase();
+ }
+
+ public static void main(String[] args) {
+ long startTime = new Date().getTime();
+ for (int i = 0; i < 100000; i++) {
+ UUIDGenerator.getInitialUUID();
+ }
+ long endTime = new Date().getTime();
+ System.out.println("getInitialUUID Difference = " + (endTime - startTime));
+
+ startTime = new Date().getTime();
+ for (int i = 0; i < 100000; i++) {
+ UUIDGenerator.getUUID();
+ }
+ endTime = new Date().getTime();
+ System.out.println("getUUID Difference = " + (endTime - startTime));
+ }
+}
diff --git a/src/org/apache/ws/commons/om/util/XPathEvaluator.java b/src/org/apache/ws/commons/om/util/XPathEvaluator.java
new file mode 100644
index 0000000..35a5c82
--- /dev/null
+++ b/src/org/apache/ws/commons/om/util/XPathEvaluator.java
@@ -0,0 +1,21 @@
+package org.apache.ws.commons.om.util;
+
+import org.apache.ws.commons.om.xpath.AXIOMXPath;
+import org.jaxen.SimpleNamespaceContext;
+
+import java.util.List;
+
+public class XPathEvaluator {
+
+ public List evaluateXpath(String xpathExpression, Object element, String nsURI) throws Exception{
+ AXIOMXPath xpath = new AXIOMXPath(xpathExpression);
+ if (nsURI!=null){
+ SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
+ nsContext.addNamespace(null,nsURI);
+ xpath.setNamespaceContext(nsContext);
+ }
+ return xpath.selectNodes(element);
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/om/xpath/AXIOMXPath.java b/src/org/apache/ws/commons/om/xpath/AXIOMXPath.java
new file mode 100644
index 0000000..31e091e
--- /dev/null
+++ b/src/org/apache/ws/commons/om/xpath/AXIOMXPath.java
@@ -0,0 +1,20 @@
+package org.apache.ws.commons.om.xpath;
+
+import org.jaxen.BaseXPath;
+import org.jaxen.JaxenException;
+
+public class AXIOMXPath extends BaseXPath {
+
+ private static final long serialVersionUID = -5839161412925154639L;
+
+ /**
+ * Construct given an XPath expression string.
+ *
+ * @param xpathExpr the XPath expression.
+ * @throws org.jaxen.JaxenException if there is a syntax error while
+ * parsing the expression
+ */
+ public AXIOMXPath(String xpathExpr) throws JaxenException {
+ super(xpathExpr, new DocumentNavigator());
+ }
+}
diff --git a/src/org/apache/ws/commons/om/xpath/DocumentNavigator.java b/src/org/apache/ws/commons/om/xpath/DocumentNavigator.java
new file mode 100644
index 0000000..8e3f37b
--- /dev/null
+++ b/src/org/apache/ws/commons/om/xpath/DocumentNavigator.java
@@ -0,0 +1,738 @@
+package org.apache.ws.commons.om.xpath;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMComment;
+import org.apache.ws.commons.om.OMContainer;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMProcessingInstruction;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.jaxen.BaseXPath;
+import org.jaxen.DefaultNavigator;
+import org.jaxen.FunctionCallException;
+import org.jaxen.JaxenConstants;
+import org.jaxen.UnsupportedAxisException;
+import org.jaxen.XPath;
+import org.jaxen.saxpath.SAXPathException;
+import org.jaxen.util.SingleObjectIterator;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.FileInputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class DocumentNavigator extends DefaultNavigator {
+
+ private static final long serialVersionUID = 7325116153349780805L;
+
+ /**
+ * Returns a parsed form of the given xpath string, which will be suitable
+ * for queries on documents that use the same navigator as this one.
+ *
+ * @param xpath the XPath expression
+ * @return Returns a new XPath expression object.
+ * @throws SAXPathException if the string is not a syntactically
+ * correct XPath expression
+ * @see XPath
+ */
+ public XPath parseXPath(String xpath) throws SAXPathException {
+ return new BaseXPath(xpath, this);
+ }
+
+ /**
+ * Retrieves the namespace URI of the given element node.
+ *
+ * @param object the context element node
+ * @return Returns the namespace URI of the element node.
+ */
+ public String getElementNamespaceUri(Object object) {
+ OMElement attr = (OMElement) object;
+ return attr.getQName().getNamespaceURI();
+ }
+
+ /**
+ * Retrieves the name of the given element node.
+ *
+ * @param object the context element node
+ * @return Returns the name of the element node.
+ */
+ public String getElementName(Object object) {
+ OMElement attr = (OMElement) object;
+ return attr.getQName().getLocalPart();
+ }
+
+ /**
+ * Retrieves the QName of the given element node.
+ *
+ * @param object the context element node
+ * @return Returns the QName of the element node.
+ */
+ public String getElementQName(Object object) {
+ OMElement attr = (OMElement) object;
+ String prefix = null;
+ if (attr.getNamespace() != null) {
+ prefix = attr.getNamespace().getPrefix();
+ }
+ if (prefix == null || "".equals(prefix)) {
+ return attr.getQName().getLocalPart();
+ }
+ return prefix + ":" + attr.getNamespace().getName();
+ }
+
+ /**
+ * Retrieves the namespace URI of the given attribute node.
+ *
+ * @param object the context attribute node
+ * @return Returns the namespace URI of the attribute node.
+ */
+ public String getAttributeNamespaceUri(Object object) {
+ OMAttribute attr = (OMAttribute) object;
+ return attr.getQName().getNamespaceURI();
+ }
+
+ /**
+ * Retrieves the name of the given attribute node.
+ *
+ * @param object the context attribute node
+ * @return Returns the name of the attribute node.
+ */
+ public String getAttributeName(Object object) {
+ OMAttribute attr = (OMAttribute) object;
+ return attr.getQName().getLocalPart();
+ }
+
+ /**
+ * Retrieves the QName of the given attribute node.
+ *
+ * @param object the context attribute node
+ * @return Returns the qualified name of the attribute node.
+ */
+ public String getAttributeQName(Object object) {
+ OMAttribute attr = (OMAttribute) object;
+ String prefix = attr.getNamespace().getPrefix();
+ if (prefix == null || "".equals(prefix)) {
+ return attr.getQName().getLocalPart();
+ }
+ return prefix + ":" + attr.getNamespace().getName();
+ }
+
+ /**
+ * Returns whether the given object is a document node. A document node
+ * is the node that is selected by the xpath expression <code>/</code>.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is a document node,
+ * else <code>false</code> .
+ */
+ public boolean isDocument(Object object) {
+ return object instanceof OMDocument;
+ }
+
+ /**
+ * Returns whether the given object is an element node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is an element node,
+ * else <code>false</code> .
+ */
+ public boolean isElement(Object object) {
+ return object instanceof OMElement;
+ }
+
+ /**
+ * Returns whether the given object is an attribute node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is an attribute node,
+ * else <code>false</code> .
+ */
+ public boolean isAttribute(Object object) {
+ return object instanceof OMAttribute;
+ }
+
+ /**
+ * Returns whether the given object is a namespace node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is a namespace node,
+ * else <code>false</code> .
+ */
+ public boolean isNamespace(Object object) {
+ return object instanceof OMNamespace;
+ }
+
+ /**
+ * Returns whether the given object is a comment node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is a comment node,
+ * else <code>false</code> .
+ */
+ public boolean isComment(Object object) {
+ return (object instanceof OMComment);
+ }
+
+ /**
+ * Returns whether the given object is a text node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is a text node,
+ * else <code>false</code> .
+ */
+ public boolean isText(Object object) {
+ return (object instanceof OMText);
+ }
+
+ /**
+ * Returns whether the given object is a processing-instruction node.
+ *
+ * @param object the object to test
+ * @return Returns <code>true</code> if the object is a processing-instruction node,
+ * else <code>false</code> .
+ */
+ public boolean isProcessingInstruction(Object object) {
+ return (object instanceof OMProcessingInstruction);
+ }
+
+ /**
+ * Retrieves the string-value of a comment node.
+ * This may be the empty string if the comment is empty,
+ * but must not be null.
+ *
+ * @param object the comment node
+ * @return Returns the string-value of the node.
+ */
+ public String getCommentStringValue(Object object) {
+ return ((OMComment) object).getValue();
+ }
+
+ /**
+ * Retrieves the string-value of an element node.
+ * This may be the empty string if the element is empty,
+ * but must not be null.
+ *
+ * @param object the comment node.
+ * @return Returns the string-value of the node.
+ */
+ public String getElementStringValue(Object object) {
+ if (isElement(object)) {
+ return getStringValue((OMElement) object, new StringBuffer())
+ .toString();
+ }
+ return null;
+ }
+
+ private StringBuffer getStringValue(OMNode node, StringBuffer buffer) {
+ if (isText(node)) {
+ buffer.append(((OMText) node).getText());
+ } else if (node instanceof OMElement) {
+ Iterator children = ((OMElement) node).getChildren();
+ while (children.hasNext()) {
+ getStringValue((OMNode) children.next(), buffer);
+ }
+ }
+ return buffer;
+ }
+
+ /**
+ * Retrieves the string-value of an attribute node.
+ * This should be the XML 1.0 normalized attribute value.
+ * This may be the empty string but must not be null.
+ *
+ * @param object the attribute node
+ * @return Returns the string-value of the node.
+ */
+ public String getAttributeStringValue(Object object) {
+ return ((OMAttribute) object).getAttributeValue();
+ }
+
+ /**
+ * Retrieves the string-value of a namespace node.
+ * This is generally the namespace URI.
+ * This may be the empty string but must not be null.
+ *
+ * @param object the namespace node
+ * @return Returns the string-value of the node.
+ */
+ public String getNamespaceStringValue(Object object) {
+ return ((OMNamespace) object).getName();
+ }
+
+ /**
+ * Retrieve the string-value of a text node.
+ * This must not be null and should not be the empty string.
+ * The XPath data model does not allow empty text nodes.
+ *
+ * @param object the text node
+ * @return Returns the string-value of the node.
+ */
+ public String getTextStringValue(Object object) {
+ return ((OMText) object).getText();
+ }
+
+ /**
+ * Retrieves the namespace prefix of a namespace node.
+ *
+ * @param object the namespace node
+ * @return Returns the prefix associated with the node.
+ */
+ public String getNamespacePrefix(Object object) {
+ return ((OMNamespace) object).getPrefix();
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>child</code>
+ * XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the child axis are
+ * not supported by this object model
+ */
+ public Iterator getChildAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ if (contextNode instanceof OMContainer) {
+ return ((OMContainer) contextNode).getChildren();
+ }
+ return JaxenConstants.EMPTY_ITERATOR;
+ }
+
+ public Iterator getDescendantAxisIterator(Object object) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getDescendantAxisIterator(object);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>attribute</code>
+ * XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the attribute axis are
+ * not supported by this object model
+ */
+ public Iterator getAttributeAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ if (isElement(contextNode)) {
+ ArrayList attributes = new ArrayList();
+ Iterator i = ((OMElement) contextNode).getAllAttributes();
+ while (i != null && i.hasNext()) {
+ attributes.add(
+ new OMAttributeEx((OMAttribute) i.next(),
+ (OMContainer) contextNode));
+ }
+ return attributes.iterator();
+ }
+ return JaxenConstants.EMPTY_ITERATOR;
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>namespace</code>
+ * XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the namespace axis are
+ * not supported by this object model
+ */
+ public Iterator getNamespaceAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ if (!(contextNode instanceof OMContainer &&
+ contextNode instanceof OMElement)) {
+ return JaxenConstants.EMPTY_ITERATOR;
+ }
+ List nsList = new ArrayList();
+ HashSet prefixes = new HashSet();
+ for (OMContainer context = (OMContainer) contextNode;
+ context != null && !(context instanceof OMDocument);
+ context = ((OMElement) context).getParent()) {
+ OMElement element = (OMElement) context;
+ ArrayList declaredNS = new ArrayList();
+ Iterator i = element.getAllDeclaredNamespaces();
+ while (i != null && i.hasNext()) {
+ declaredNS.add(i.next());
+ }
+ declaredNS.add(element.getNamespace());
+ for (Iterator iter = element.getAllAttributes();
+ iter != null && iter.hasNext();) {
+ OMAttribute attr = (OMAttribute) iter.next();
+ declaredNS.add(attr.getNamespace());
+ }
+ for (Iterator iter = declaredNS.iterator();
+ iter != null && iter.hasNext();) {
+ OMNamespace namespace = (OMNamespace) iter.next();
+ if (namespace != null) {
+ String prefix = namespace.getPrefix();
+ if (prefix != null && !prefixes.contains(prefix)) {
+ prefixes.add(prefix);
+ nsList.add(new OMNamespaceEx(namespace, context));
+ }
+ }
+ }
+ }
+ nsList.add(
+ new OMNamespaceEx(
+ new OMNamespaceImpl(
+ "http://www.w3.org/XML/1998/namespace", "xml"),
+ (OMContainer) contextNode));
+ return nsList.iterator();
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>self</code> xpath
+ * axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the self axis are
+ * not supported by this object model
+ */
+ public Iterator getSelfAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getSelfAxisIterator(contextNode);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the
+ * <code>descendant-or-self</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the descendant-or-self axis are
+ * not supported by this object model
+ */
+ public Iterator getDescendantOrSelfAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getDescendantOrSelfAxisIterator(contextNode);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the
+ * <code>ancestor-or-self</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the ancestor-or-self axis are
+ * not supported by this object model
+ */
+ public Iterator getAncestorOrSelfAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getAncestorOrSelfAxisIterator(contextNode);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>parent</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the parent axis are
+ * not supported by this object model
+ */
+ public Iterator getParentAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ if (contextNode instanceof OMNode) {
+ return new SingleObjectIterator(((OMNode) contextNode).getParent());
+ } else if (contextNode instanceof OMNamespaceEx) {
+ return new SingleObjectIterator(
+ ((OMNamespaceEx) contextNode).getParent());
+ } else if (contextNode instanceof OMAttributeEx) {
+ return new SingleObjectIterator(
+ ((OMAttributeEx) contextNode).getParent());
+ }
+ return JaxenConstants.EMPTY_ITERATOR;
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>ancestor</code>
+ * XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the ancestor axis are
+ * not supported by this object model
+ */
+ public Iterator getAncestorAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getAncestorAxisIterator(contextNode);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the
+ * <code>following-sibling</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the following-sibling axis are
+ * not supported by this object model
+ */
+ public Iterator getFollowingSiblingAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ ArrayList list = new ArrayList();
+ if (contextNode != null && contextNode instanceof OMNode) {
+ while (contextNode != null && contextNode instanceof OMNode) {
+ contextNode = ((OMNode) contextNode).getNextOMSibling();
+ if (contextNode != null)
+ list.add(contextNode);
+ }
+ }
+ return list.iterator();
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the
+ * <code>preceding-sibling</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the preceding-sibling axis are
+ * not supported by this object model
+ */
+ public Iterator getPrecedingSiblingAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ ArrayList list = new ArrayList();
+ if (contextNode != null && contextNode instanceof OMNode) {
+ while (contextNode != null && contextNode instanceof OMNode) {
+ contextNode = ((OMNode) contextNode).getPreviousOMSibling();
+ if (contextNode != null)
+ list.add(contextNode);
+ }
+ }
+ return list.iterator();
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>following</code>
+ * XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the following axis are
+ * not supported by this object model
+ */
+ public Iterator getFollowingAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getFollowingAxisIterator(contextNode);
+ }
+
+ /**
+ * Retrieves an <code>Iterator</code> matching the <code>preceding</code> XPath axis.
+ *
+ * @param contextNode the original context node
+ * @return Returns an Iterator capable of traversing the axis, not null.
+ * @throws UnsupportedAxisException if the semantics of the preceding axis are
+ * not supported by this object model
+ */
+ public Iterator getPrecedingAxisIterator(Object contextNode) throws UnsupportedAxisException {
+ //TODO: Fix this better?
+ return super.getPrecedingAxisIterator(contextNode);
+ }
+
+ /**
+ * Loads a document from the given URI.
+ *
+ * @param uri the URI of the document to load
+ * @return Returns the document.
+ * @throws FunctionCallException if the document could not be loaded
+ */
+ public Object getDocument(String uri)
+ throws FunctionCallException {
+ try {
+ XMLStreamReader parser;
+ XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
+ xmlInputFactory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
+ if (uri.indexOf(':') == -1) {
+ parser = xmlInputFactory.createXMLStreamReader(
+ new FileInputStream(uri));
+ } else {
+ URL url = new URL(uri);
+ parser = xmlInputFactory.createXMLStreamReader(
+ url.openStream());
+ }
+ StAXOMBuilder builder =
+ new StAXOMBuilder(parser);
+ return builder.getDocumentElement().getParent();
+ } catch (Exception e) {
+ throw new FunctionCallException(e);
+ }
+ }
+
+ /**
+ * Returns the element whose ID is given by elementId.
+ * If no such element exists, returns null.
+ * Attributes with the name "ID" are not of type ID unless so defined.
+ * Implementations that do not know whether attributes are of type ID or
+ * not are expected to return null.
+ *
+ * @param contextNode a node from the document in which to look for the
+ * id
+ * @param elementId id to look for
+ * @return Returns element whose ID is given by elementId, or null if no such
+ * element exists in the document or if the implementation
+ * does not know about attribute types.
+ */
+ public Object getElementById(Object contextNode, String elementId) {
+ //TODO: Fix this better?
+ return super.getElementById(contextNode, elementId);
+ }
+
+ /**
+ * Returns the document node that contains the given context node.
+ *
+ * @param contextNode the context node
+ * @return Returns the document of the context node.
+ * @see #isDocument(Object)
+ */
+ public Object getDocumentNode(Object contextNode) {
+ if (contextNode instanceof OMDocument) {
+ return contextNode;
+ }
+ return getDocumentNode(((OMNode) contextNode).getParent());
+ }
+
+ /**
+ * Translates a namespace prefix to a namespace URI, <b>possibly</b>
+ * considering a particular element node.
+ * <p/>
+ * Strictly speaking, prefix-to-URI translation should occur
+ * irrespective of any element in the document. This method
+ * is provided to allow a non-conforming ease-of-use enhancement.
+ * </p>
+ *
+ * @param prefix the prefix to translate
+ * @param element the element to consider during translation
+ * @return Returns the namespace URI associated with the prefix.
+ */
+ public String translateNamespacePrefixToUri(String prefix, Object element) {
+ //TODO: Fix this better?
+ return super.translateNamespacePrefixToUri(prefix, element);
+ }
+
+ /**
+ * Retrieves the target of a processing-instruction.
+ *
+ * @param object the context processing-instruction node
+ * @return Returns the target of the processing-instruction node.
+ */
+ public String getProcessingInstructionTarget(Object object) {
+ return ((OMProcessingInstruction)object).getTarget();
+ }
+
+ /**
+ * Retrieves the data of a processing-instruction.
+ *
+ * @param object the context processing-instruction node
+ * @return Returns the data of the processing-instruction node.
+ */
+ public String getProcessingInstructionData(Object object) {
+ return ((OMProcessingInstruction)object).getValue();
+ }
+
+ /**
+ * Returns a number that identifies the type of node that the given
+ * object represents in this navigator. See org.jaxen.pattern.Pattern
+ *
+ * @param node ????
+ * @return Returns short.
+ */
+ public short getNodeType(Object node) {
+ //TODO: Fix this better?
+ return super.getNodeType(node);
+ }
+
+ /**
+ * Returns the parent of the given context node.
+ * <p/>
+ * The parent of any node must either be a document
+ * node or an element node.
+ *
+ * @param contextNode the context node
+ * @return Returns the parent of the context node, or null if this is a document node.
+ * @throws UnsupportedAxisException if the parent axis is not
+ * supported by the model
+ * @see #isDocument
+ * @see #isElement
+ */
+ public Object getParentNode(Object contextNode) throws UnsupportedAxisException {
+ if (contextNode == null ||
+ contextNode instanceof OMDocument) {
+ return null;
+ } else if (contextNode instanceof OMAttributeEx) {
+ return ((OMAttributeEx) contextNode).getParent();
+ } else if (contextNode instanceof OMNamespaceEx) {
+ return ((OMNamespaceEx) contextNode).getParent();
+ }
+ return ((OMNode) contextNode).getParent();
+ }
+
+ class OMNamespaceEx implements OMNamespace {
+ OMNamespace originalNsp = null;
+ OMContainer parent = null;
+
+ OMNamespaceEx(OMNamespace nsp, OMContainer parent) {
+ originalNsp = nsp;
+ this.parent = parent;
+ }
+
+ public boolean equals(String uri, String prefix) {
+ return originalNsp.equals(uri, prefix);
+ }
+
+ public String getPrefix() {
+ return originalNsp.getPrefix();
+ }
+
+ public String getName() {
+ return originalNsp.getName();
+ }
+
+ public OMContainer getParent() {
+ return parent;
+ }
+ }
+
+ class OMAttributeEx implements OMAttribute {
+ OMAttribute attribute = null;
+ OMContainer parent = null;
+
+ OMAttributeEx(OMAttribute attribute, OMContainer parent) {
+ this.attribute = attribute;
+ this.parent = parent;
+ }
+
+ public String getLocalName() {
+ return attribute.getLocalName();
+ }
+
+ public void setLocalName(String localName) {
+ attribute.setLocalName(localName);
+ }
+
+ public String getAttributeValue() {
+ return attribute.getAttributeValue();
+ }
+
+ public void setAttributeValue(String value) {
+ attribute.setAttributeValue(value);
+ }
+
+ public void setOMNamespace(OMNamespace omNamespace) {
+ attribute.setOMNamespace(omNamespace);
+ }
+
+ public OMNamespace getNamespace() {
+ return attribute.getNamespace();
+ }
+
+ public QName getQName() {
+ return attribute.getQName();
+ }
+
+ public OMContainer getParent() {
+ return parent;
+ }
+ }
+}
+
diff --git a/src/org/apache/ws/commons/soap/SOAP11Constants.java b/src/org/apache/ws/commons/soap/SOAP11Constants.java
new file mode 100644
index 0000000..7477ebb
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAP11Constants.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+
+public interface SOAP11Constants extends SOAPConstants {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public static final String SOAP_ENVELOPE_NAMESPACE_URI = "http://schemas.xmlsoap.org/soap/envelope/";
+
+ /**
+ * Field ATTR_ACTOR
+ */
+ public static final String ATTR_ACTOR = "actor";
+
+ /**
+ * Field SOAP_FAULT_CODE_LOCAL_NAME
+ */
+ public static final String SOAP_FAULT_CODE_LOCAL_NAME = "faultcode";
+ /**
+ * Field SOAP_FAULT_STRING_LOCAL_NAME
+ */
+ public static final String SOAP_FAULT_STRING_LOCAL_NAME = "faultstring";
+ /**
+ * Field SOAP_FAULT_ACTOR_LOCAL_NAME
+ */
+ public static final String SOAP_FAULT_ACTOR_LOCAL_NAME = "faultactor";
+
+ public static final String SOAP_FAULT_DETAIL_LOCAL_NAME = "detail";
+
+ //SOAP 1.2 Content Type
+ public static final String SOAP_11_CONTENT_TYPE = "text/xml";
+
+ // -------- SOAP Fault Codes ------------------------------
+ public static final String FAULT_CODE_SENDER = "Client";
+ public static final String FAULT_CODE_RECEIVER = "Server";
+
+ public static final String SOAP_ACTOR_NEXT = "http://schemas.xmlsoap.org/soap/actor/next";
+}
diff --git a/src/org/apache/ws/commons/soap/SOAP12Constants.java b/src/org/apache/ws/commons/soap/SOAP12Constants.java
new file mode 100644
index 0000000..22494e9
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAP12Constants.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+
+public interface SOAP12Constants extends SOAPConstants {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public String SOAP_ENVELOPE_NAMESPACE_URI =
+ "http://www.w3.org/2003/05/soap-envelope";
+
+ public static final String SOAP_ROLE = "role";
+ public static final String SOAP_RELAY = "relay";
+
+ // SOAP Fault Code
+ public static final String SOAP_FAULT_CODE_LOCAL_NAME = "Code";
+ public static final String SOAP_FAULT_SUB_CODE_LOCAL_NAME = "Subcode";
+ public static final String SOAP_FAULT_VALUE_LOCAL_NAME = "Value";
+
+ // SOAP Fault Codes
+ public static final String SOAP_FAULT_VALUE_VERSION_MISMATCH = "VersionMismatch";
+ public static final String SOAP_FAULT_VALUE_MUST_UNDERSTAND = "MustUnderstand";
+ public static final String SOAP_FAULT_VALUE_DATA_ENCODING_UKNOWN = "DataEncodingUnknown";
+ public static final String SOAP_FAULT_VALUE_SENDER = "Sender";
+ public static final String SOAP_FAULT_VALUE_RECEIVER = "Receiver";
+
+ // SOAP Fault Reason
+ public static final String SOAP_FAULT_REASON_LOCAL_NAME = "Reason";
+ public static final String SOAP_FAULT_TEXT_LOCAL_NAME = "Text";
+ public static final String SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME = "lang";
+ public static final String SOAP_FAULT_TEXT_LANG_ATTR_NS_URI = "http://www.w3.org/XML/1998/namespace";
+ public static final String SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX = "xml";
+
+ // SOAP Fault Node
+ public static final String SOAP_FAULT_NODE_LOCAL_NAME = "Node";
+
+ // SOAP Fault Detail
+ public static final String SOAP_FAULT_DETAIL_LOCAL_NAME = "Detail";
+
+ // SOAP Fault Role
+ public static final String SOAP_FAULT_ROLE_LOCAL_NAME = "Role";
+
+ //SOAP 1.2 Content Type
+ public static final String SOAP_12_CONTENT_TYPE = "application/soap+xml";
+
+ // -------- SOAP Fault Codes ------------------------------
+ public static final String FAULT_CODE_SENDER = "Sender";
+ public static final String FAULT_CODE_RECEIVER = "Receiver";
+
+ public static final String SOAP_ROLE_NEXT = "http://www.w3.org/2003/05/soap-envelope/role/next";
+ public static final String SOAP_ROLE_NONE = "http://www.w3.org/2003/05/soap-envelope/role/next";
+ public static final String SOAP_ROLE_ULTIMATE_RECEIVER = "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver";
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPBody.java b/src/org/apache/ws/commons/soap/SOAPBody.java
new file mode 100644
index 0000000..f3e7dea
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPBody.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+
+/**
+ * An object that represents the contents of the SOAP body
+ * element in a SOAP message. B SOAP body element consists of XML data
+ * that affects the way the application-specific content is processed.
+ * <P>
+ * B <code>SOAPBody</code> object contains <code>OMBodyBlock</code>
+ * objects, which have the content for the SOAP body.
+ * B <code>SOAPFault</code> object, which carries status and/or
+ * error information, is an example of a <code>OMBodyBlock</code> object.
+ */
+public interface SOAPBody extends OMElement {
+ /**
+ * Creates a new <code>SOAPFault</code> object and adds it to
+ * this <code>SOAPBody</code> object.
+ *
+ * @param e
+ * @return the new <code>SOAPFault</code> object
+ * @throws org.apache.ws.commons.om.OMException
+ * if there is a SOAP error
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ */
+ public abstract SOAPFault addFault(Exception e) throws OMException;
+
+ /**
+ * Indicates whether a <code>SOAPFault</code> object exists in
+ * this <code>SOAPBody</code> object.
+ *
+ * @return <code>true</code> if a <code>SOAPFault</code> object exists in
+ * this <code>SOAPBody</code> object; <code>false</code>
+ * otherwise
+ */
+ public abstract boolean hasFault();
+
+ /**
+ * Returns the <code>SOAPFault</code> object in this <code>SOAPBody</code>
+ * object.
+ *
+ * @return the <code>SOAPFault</code> object in this <code>SOAPBody</code>
+ * object
+ */
+ public abstract SOAPFault getFault();
+
+ /**
+ * @param soapFault
+ * @throws OMException
+ */
+ public abstract void addFault(SOAPFault soapFault) throws OMException;
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPConstants.java b/src/org/apache/ws/commons/soap/SOAPConstants.java
new file mode 100644
index 0000000..b9a59dc
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPConstants.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public interface SOAPConstants {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ /**
+ * Field SOAP_DEFAULT_NAMESPACE_PREFIX
+ */
+ public static final String SOAP_DEFAULT_NAMESPACE_PREFIX = "soapenv";
+ /**
+ * Field SOAPENVELOPE_LOCAL_NAME
+ */
+ public static final String SOAPENVELOPE_LOCAL_NAME = "Envelope";
+
+ /**
+ * Field HEADER_LOCAL_NAME
+ */
+ public static final String HEADER_LOCAL_NAME = "Header";
+
+ /**
+ * Field BODY_LOCAL_NAME
+ */
+ public static final String BODY_LOCAL_NAME = "Body";
+ /**
+ * Field BODY_NAMESPACE_PREFIX
+ */
+ public static final String BODY_NAMESPACE_PREFIX =
+ SOAP_DEFAULT_NAMESPACE_PREFIX;
+ /**
+ * Field BODY_FAULT_LOCAL_NAME
+ */
+ public static final String BODY_FAULT_LOCAL_NAME = "Fault";
+
+ /**
+ * Field ATTR_MUSTUNDERSTAND
+ */
+ public static final String ATTR_MUSTUNDERSTAND = "mustUnderstand";
+ public static final String ATTR_MUSTUNDERSTAND_TRUE = "true";
+ public static final String ATTR_MUSTUNDERSTAND_FALSE = "false";
+ public static final String ATTR_MUSTUNDERSTAND_0 = "0";
+ public static final String ATTR_MUSTUNDERSTAND_1 = "1";
+ /**
+ * Field SOAPFAULT_LOCAL_NAME
+ */
+ public static final String SOAPFAULT_LOCAL_NAME = "Fault";
+ /**
+ * Field SOAPFAULT_DETAIL_LOCAL_NAME
+ */
+ public static final String SOAPFAULT_DETAIL_LOCAL_NAME = "detail";
+
+ /**
+ * Field SOAPFAULT_NAMESPACE_PREFIX
+ */
+ public static final String SOAPFAULT_NAMESPACE_PREFIX =
+ SOAP_DEFAULT_NAMESPACE_PREFIX;
+
+ public static final String SOAP_FAULT_DETAIL_EXCEPTION_ENTRY = "Exception";
+
+ // -------- SOAP Fault Codes ------------------------------
+ public static final String FAULT_CODE_VERSION_MISMATCH = "env:VersionMismatch";
+ public static final String FAULT_CODE_MUST_UNDERSTAND = "env:MustUnderstand";
+ public static final String FAULT_CODE_DATA_ENCODING_UNKNOWN = "env:DataEncodingUnknown";
+
+ // Followings are different in SOAP 1.1 and 1.2 specifications
+ public static final String FAULT_CODE_SENDER = "";
+ public static final String FAULT_CODE_RECEIVER = "";
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPEnvelope.java b/src/org/apache/ws/commons/soap/SOAPEnvelope.java
new file mode 100644
index 0000000..1f6182f
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPEnvelope.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+
+/**
+ * Interface SOAPEnvelope
+ */
+public interface SOAPEnvelope extends OMElement {
+ /**
+ * Returns the <CODE>SOAPHeader</CODE> object for this <CODE>
+ * SOAPEnvelope</CODE> object.
+ * <P> This SOAPHeader will just be a container for all the headers in the
+ * <CODE>OMMessage</CODE>
+ * </P>
+ *
+ * @return the <CODE>SOAPHeader</CODE> object or <CODE>
+ * null</CODE> if there is none
+ * @throws org.apache.ws.commons.om.OMException
+ * if there is a problem
+ * obtaining the <CODE>SOAPHeader</CODE> object
+ */
+ public abstract SOAPHeader getHeader() throws OMException;
+
+ /**
+ * Returns the <CODE>SOAPBody</CODE> object associated with
+ * this <CODE>SOAPEnvelope</CODE> object.
+ * <P> This SOAPBody will just be a container for all the BodyElements in the
+ * <CODE>OMMessage</CODE>
+ * </P>
+ *
+ * @return the <CODE>SOAPBody</CODE> object for this <CODE>
+ * SOAPEnvelope</CODE> object or <CODE>null</CODE> if there
+ * is none
+ * @throws OMException if there is a problem
+ * obtaining the <CODE>SOAPBody</CODE> object
+ */
+ public abstract SOAPBody getBody() throws OMException;
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFactory.java b/src/org/apache/ws/commons/soap/SOAPFactory.java
new file mode 100644
index 0000000..89c2b96
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFactory.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+
+
+public interface SOAPFactory extends OMFactory {
+
+ public String getSoapVersionURI();
+
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public SOAPMessage createSOAPMessage(OMXMLParserWrapper builder);
+ public SOAPMessage createSOAPMessage(SOAPEnvelope envelope, OMXMLParserWrapper parserWrapper);
+
+ /**
+ * @param builder
+ * @return Returns SOAPEnvelope.
+ */
+ public SOAPEnvelope createSOAPEnvelope(OMXMLParserWrapper builder);
+
+ /**
+ * @return Returns SOAPEnvelope.
+ */
+ public SOAPEnvelope createSOAPEnvelope() throws SOAPProcessingException;
+
+ /**
+ * @param envelope
+ * @return Returns SOAPHeader.
+ */
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope) throws SOAPProcessingException;
+
+ /**
+ * @param envelope
+ * @param builder
+ * @return Returns SOAPHeader.
+ */
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder);
+
+ /**
+ * @param localName
+ * @param ns
+ * @return Returns SOAPHeaderBlock.
+ */
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException;
+
+ /**
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ * @return Returns SOAPHeaderBlock.
+ */
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent,
+ OMXMLParserWrapper builder) throws SOAPProcessingException;
+
+ /**
+ * @param parent
+ * @param e
+ * @return Returns SOAPFault.
+ */
+ public SOAPFault createSOAPFault(SOAPBody parent, Exception e) throws SOAPProcessingException;
+
+ public SOAPFault createSOAPFault(SOAPBody parent) throws SOAPProcessingException;
+
+ /**
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFault.
+ */
+ public SOAPFault createSOAPFault(SOAPBody parent,
+ OMXMLParserWrapper builder);
+
+ /**
+ * @param envelope
+ * @return Returns SOAPBody.
+ */
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope) throws SOAPProcessingException;
+
+ /**
+ * @param envelope
+ * @param builder
+ * @return Returns SOAPBody.
+ */
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder);
+
+ /* ========================
+ = SOAPFaultCode =
+ ======================== */
+
+ /**
+ * Code eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultCode.
+ */
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent) throws SOAPProcessingException;
+
+ /**
+ * Code eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultCode.
+ */
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent,
+ OMXMLParserWrapper builder);
+
+
+ /*========================
+ = SOAPFaultCodeValue =
+ ======================== */
+ /**
+ * Value eii under Code (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultValue.
+ */
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent) throws SOAPProcessingException;
+
+ /**
+ * Value eii under Code (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultValue.
+ */
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent,
+ OMXMLParserWrapper builder);
+
+ /*========================
+ = SOAPFaultSubCode =
+ ======================== */
+
+ /**
+ * SubCode eii under Value (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultValue.
+ */
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent) throws SOAPProcessingException;
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder);
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent) throws SOAPProcessingException;
+
+ /**
+ * SubCode eii under Value (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultSubCode.
+ */
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent,
+ OMXMLParserWrapper builder);
+
+ /**
+ * SubCode eii under SubCode (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultSubCode.
+ */
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent) throws SOAPProcessingException;
+
+ /**
+ * SubCode eii under SubCode (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultSubCode.
+ */
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder);
+
+
+ /*========================
+ = SOAPFaultReason =
+ ======================== */
+
+ /**
+ * Reason eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultReason.
+ */
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent) throws SOAPProcessingException;
+
+ /**
+ * Reason eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultReason.
+ */
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent,
+ OMXMLParserWrapper builder);
+
+ /*========================
+ = SOAPFaultReasonText =
+ ======================== */
+
+ /**
+ * SubCode eii under SubCode (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultText.
+ */
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent) throws SOAPProcessingException;
+
+ /**
+ * SubCode eii under SubCode (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultText.
+ */
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent,
+ OMXMLParserWrapper builder);
+
+
+ /*========================
+ = SOAPFaultNode =
+ ======================== */
+
+ /**
+ * Node eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultNode.
+ */
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent) throws SOAPProcessingException;
+
+ /**
+ * Node eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultNode.
+ */
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent,
+ OMXMLParserWrapper builder);
+
+ /*========================
+ = SOAPFaultRole =
+ ======================== */
+
+ /**
+ * Role eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultRole.
+ */
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent) throws SOAPProcessingException;
+
+ /**
+ * Role eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultRole.
+ */
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent,
+ OMXMLParserWrapper builder);
+
+ /*========================
+ = SOAPFaultDetail =
+ ======================== */
+
+ /**
+ * Detail eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @return Returns SOAPFaultDetail.
+ */
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent) throws SOAPProcessingException;
+
+ /**
+ * Role eii under SOAPFault (parent)
+ *
+ * @param parent
+ * @param builder
+ * @return Returns SOAPFaultDetail.
+ */
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent,
+ OMXMLParserWrapper builder);
+
+
+ /**
+ * Method getDefaultEnvelope
+ *
+ * @return Returns SOAPEnvelope.
+ */
+ public SOAPEnvelope getDefaultEnvelope() throws SOAPProcessingException;
+
+ public SOAPEnvelope getDefaultFaultEnvelope() throws SOAPProcessingException;
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFault.java b/src/org/apache/ws/commons/soap/SOAPFault.java
new file mode 100644
index 0000000..9a3373c
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFault.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+
+
+/**
+ * An element in the <CODE>SOAPBody</CODE> object that contains
+ * error and/or status information. This information may relate to
+ * errors in the <CODE>OMMessage</CODE> object or to problems
+ * that are not related to the content in the message itself.
+ * Problems not related to the message itself are generally errors
+ * in processing, such as the inability to communicate with an
+ * upstream server.
+ * <P>
+ * The <CODE>SOAPFault</CODE> interface provides methods for
+ * retrieving the information contained in a <CODE>
+ * SOAPFault</CODE> object and for setting the fault code, the
+ * fault actor, and a string describing the fault. B fault code is
+ * one of the codes defined in the SOAP 1.1 specification that
+ * describe the fault. An actor is an intermediate recipient to
+ * whom a message was routed. The message path may include one or
+ * more actors, or, if no actors are specified, the message goes
+ * only to the default actor, which is the final intended
+ * recipient.
+ */
+public interface SOAPFault extends OMElement {
+
+ /**
+ * SOAPFaultCode is a mandatory item in a Fault, in SOAP 1.2 specification
+ *
+ * @param soapFaultCode
+ */
+ public void setCode(SOAPFaultCode soapFaultCode) throws SOAPProcessingException;
+
+ public SOAPFaultCode getCode();
+
+ /**
+ * SOAPFaultReason is a mandatory item in a Fault, in SOAP 1.2 specification
+ *
+ * @param reason
+ */
+ public void setReason(SOAPFaultReason reason) throws SOAPProcessingException;
+
+ public SOAPFaultReason getReason();
+
+ /**
+ * SOAPFaultNode is an optional item in a Fault, in SOAP 1.2 specification
+ *
+ * @param node
+ */
+ public void setNode(SOAPFaultNode node) throws SOAPProcessingException;
+
+ public SOAPFaultNode getNode();
+
+ /**
+ * SOAPFaultRoleImpl is an optional item in a Fault, in SOAP 1.2 specification
+ *
+ * @param role
+ */
+ public void setRole(SOAPFaultRole role) throws SOAPProcessingException;
+
+ public SOAPFaultRole getRole();
+
+ /**
+ * SOAPFaultRoleImpl is an optional item in a Fault, in SOAP 1.2 specification
+ *
+ * @param detail
+ */
+ public void setDetail(SOAPFaultDetail detail) throws SOAPProcessingException;
+
+ public SOAPFaultDetail getDetail();
+
+ /**
+ * Returns Exception if there is one in the SOAP fault.
+ * <p/>
+ * If the exception is like;
+ * <SOAPFault>
+ * <Detail>
+ * <Exception> stack trace goes here </Exception>
+ * </Detail>
+ * </SOAPFault>
+ *
+ * @return Returns Exception.
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ */
+ public Exception getException() throws OMException;
+
+ public void setException(Exception e) throws OMException;
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultCode.java b/src/org/apache/ws/commons/soap/SOAPFaultCode.java
new file mode 100644
index 0000000..de8508d
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultCode.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultCode extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * @param value
+ */
+ public void setValue(SOAPFaultValue value) throws SOAPProcessingException;
+
+ /**
+ * @return Returns SOAPFaultValue.
+ */
+ public SOAPFaultValue getValue();
+
+ /**
+ * @param value
+ */
+ public void setSubCode(SOAPFaultSubCode value) throws SOAPProcessingException;
+
+ /**
+ * @return Returns SOAPFaultSubCode.
+ */
+ public SOAPFaultSubCode getSubCode();
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultDetail.java b/src/org/apache/ws/commons/soap/SOAPFaultDetail.java
new file mode 100644
index 0000000..c5a5ab1
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultDetail.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+import java.util.Iterator;
+
+
+/**
+ * The Detail element information item is intended for carrying application
+ * specific error information related to the SOAP Body .
+ * <p/>
+ * The Detail element information item has:
+ * A [local name] of Detail .
+ * A [namespace name] of http://www.w3.org/2003/05/soap-envelope .
+ * Zero or more attribute information items in its [attributes] property.
+ * Zero or more child element information items in its [children] property.
+ */
+public interface SOAPFaultDetail extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public void addDetailEntry(OMElement detailElement);
+
+ public Iterator getAllDetailEntries();
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultNode.java b/src/org/apache/ws/commons/soap/SOAPFaultNode.java
new file mode 100644
index 0000000..f00aaa3
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultNode.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultNode extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * each SOAP node is identified by a URI. The value of the Node element
+ * information item is the URI that identifies the SOAP node that generated
+ * the fault. SOAP nodes that do not act as the ultimate SOAP receiver MUST
+ * include this element information item. An ultimate SOAP receiver MAY
+ * include this element information item to indicate explicitly that it
+ * generated the fault.
+ *
+ * @param uri
+ */
+ public void setNodeValue(String uri);
+
+ public String getNodeValue();
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultReason.java b/src/org/apache/ws/commons/soap/SOAPFaultReason.java
new file mode 100644
index 0000000..f0a1155
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultReason.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultReason extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public void setSOAPText(SOAPFaultText soapFaultText) throws SOAPProcessingException;
+
+ public SOAPFaultText getSOAPText();
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultRole.java b/src/org/apache/ws/commons/soap/SOAPFaultRole.java
new file mode 100644
index 0000000..7eee7ef
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultRole.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+
+/**
+ * The Role element information item identifies the role the node was operating
+ * in at the point the fault occurred.
+ * <p/>
+ * The Role element information item has:
+ * A [local name] of Role .
+ * A [namespace name] of http://www.w3.org/2003/05/soap-envelope .
+ */
+public interface SOAPFaultRole extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * The value of the Role element information item MUST be one of the roles
+ * assumed by the node during processing of the message
+ *
+ * @param uri
+ */
+ public void setRoleValue(String uri);
+
+ public String getRoleValue();
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultSubCode.java b/src/org/apache/ws/commons/soap/SOAPFaultSubCode.java
new file mode 100644
index 0000000..c394b59
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultSubCode.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultSubCode extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * Fault SubCode contain only one mandatory Value child. This value child contains a QName
+ *
+ * @param soapFaultSubCodeValue
+ */
+ public void setValue(SOAPFaultValue soapFaultSubCodeValue) throws SOAPProcessingException;
+
+ public SOAPFaultValue getValue();
+
+
+ /**
+ * Fault SubCode can contain an optional SubCode
+ *
+ * @param subCode
+ */
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException;
+
+ public SOAPFaultSubCode getSubCode();
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultText.java b/src/org/apache/ws/commons/soap/SOAPFaultText.java
new file mode 100644
index 0000000..4bfcec8
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultText.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultText extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * lang is a mandatory attribute within the SOAPFaultText which must have
+ * SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_URI as the namespace URI and
+ * SOAP12constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX or a capitalization thereof as the prefix
+ *
+ * @param lang
+ */
+ public void setLang(String lang);
+
+ public String getLang();
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPFaultValue.java b/src/org/apache/ws/commons/soap/SOAPFaultValue.java
new file mode 100644
index 0000000..e769a61
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPFaultValue.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+public interface SOAPFaultValue extends OMElement {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPHeader.java b/src/org/apache/ws/commons/soap/SOAPHeader.java
new file mode 100644
index 0000000..1ad45c0
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPHeader.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * Interface SOAPHeader
+ */
+public interface SOAPHeader extends OMElement {
+ /**
+ * Creates a new <CODE>SOAPHeaderBlock</CODE> object initialized with the
+ * specified name and adds it to this <CODE>SOAPHeader</CODE> object.
+ *
+ * @param localName
+ * @param ns
+ * @return the new <CODE>SOAPHeaderBlock</CODE> object that was inserted
+ * into this <CODE>SOAPHeader</CODE> object
+ * @throws org.apache.ws.commons.om.OMException
+ * if a SOAP error occurs
+ */
+ public abstract SOAPHeaderBlock addHeaderBlock(String localName,
+ OMNamespace ns) throws OMException;
+
+ /**
+ * Returns a list of all the <CODE>SOAPHeaderBlock</CODE> objects in this
+ * <CODE>SOAPHeader</CODE> object that have the the specified role. An
+ * role is a global attribute that indicates the intermediate parties to
+ * whom the message should be sent. An role receives the message and then
+ * sends it to the next role. The default role is the ultimate intended
+ * recipient for the message, so if no role attribute is included in a
+ * <CODE>SOAPHeader</CODE> object, the message is sent to its ultimate
+ * destination.
+ *
+ * @param role
+ * a <CODE>String</CODE> giving the URI of the role for which
+ * to search
+ * @return Returns an <CODE>Iterator</CODE> object over all the <CODE>
+ * SOAPHeaderBlock</CODE> objects that contain the specified role
+ * @see #extractHeaderBlocks(java.lang.String)
+ * extractHeaderBlocks(java.lang.String)
+ */
+ public abstract Iterator examineHeaderBlocks(String role);
+
+ /**
+ * Returns a list of all the <CODE>SOAPHeaderBlock</CODE> objects in this
+ * <CODE>SOAPHeader</CODE> object that have the the specified role and
+ * detaches them from this <CODE>SOAPHeader</CODE> object.
+ * <P>
+ * This method allows an role to process only the parts of the <CODE>
+ * SOAPHeader</CODE> object that apply to it and to remove them before
+ * passing the message on to the next role.
+ *
+ * @param role
+ * a <CODE>String</CODE> giving the URI of the role for which
+ * to search
+ * @return Returns an <CODE>Iterator</CODE> object over all the <CODE>
+ * SOAPHeaderBlock</CODE> objects that contain the specified role
+ * @see #examineHeaderBlocks(java.lang.String)
+ * examineHeaderBlocks(java.lang.String)
+ */
+ public abstract Iterator extractHeaderBlocks(String role);
+
+ /**
+ * Returns an <code>Iterator</code> over all the
+ * <code>SOAPHeaderBlock</code> objects in this <code>SOAPHeader</code>
+ * object that have the specified role and that have a MustUnderstand
+ * attribute whose value is equivalent to <code>true</code>.
+ *
+ * @param role
+ * a <code>String</code> giving the URI of the role for which
+ * to search
+ * @return Returns an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects that contain the specified
+ * role and are marked as MustUnderstand.
+ */
+ public abstract Iterator examineMustUnderstandHeaderBlocks(String role);
+
+ /**
+ * Returns an <code>Iterator</code> over all the
+ * <code>SOAPHeaderBlock</code> objects in this <code>SOAPHeader</code>
+ * object.
+ *
+ * @return an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects contained by this
+ * <code>SOAPHeader</code>. If there are no header blocks then an
+ * empty iterator is returned.
+ */
+ public abstract Iterator examineAllHeaderBlocks();
+
+ /**
+ * Returns an <code>Iterator</code> over all the
+ * <code>SOAPHeaderBlock</code> objects in this <code>SOAPHeader </code>
+ * object and detaches them from this <code>SOAPHeader</code> object.
+ *
+ * @return Returns an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects contained by this
+ * <code>SOAPHeader</code>
+ */
+ public abstract Iterator extractAllHeaderBlocks();
+
+ /**
+ * Return all the Headers that has the Namespace URI to given NS URI.
+ *
+ * @param nsURI
+ * @return Returns ArrayList.
+ */
+ public ArrayList getHeaderBlocksWithNSURI(String nsURI);
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPHeaderBlock.java b/src/org/apache/ws/commons/soap/SOAPHeaderBlock.java
new file mode 100644
index 0000000..e3368aa
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPHeaderBlock.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+
+/**
+ * <P>An object representing the contents in the SOAP header part of the SOAP
+ * envelope. The immediate children of a <CODE> SOAPHeader</CODE> object can be
+ * represented only as <CODE> SOAPHeaderBlock</CODE> objects.</P> <P>B
+ * <CODE>SOAPHeaderBlock</CODE> object can have other <CODE>OMElement</CODE>
+ * objects as its children.</P>
+ */
+public interface SOAPHeaderBlock extends OMElement {
+ /**
+ * Sets the actor associated with this <CODE> SOAPHeaderBlock</CODE> object
+ * to the specified actor.
+ *
+ * @param roleURI a <CODE>String</CODE> giving the URI of the actor to set
+ * @throws java.lang.IllegalArgumentException
+ * if there is a problem in setting the actor.
+ * @see #getRole() getRole()
+ */
+ public abstract void setRole(String roleURI);
+
+ /**
+ * Returns the uri of the actor associated with this <CODE>
+ * SOAPHeaderBlock</CODE> object.
+ *
+ * @return a <CODE>String</CODE> giving the URI of the actor
+ * @see #setRole(java.lang.String) setRole(java.lang.String)
+ */
+ public abstract String getRole();
+
+ /**
+ * Sets the mustUnderstand attribute for this <CODE> SOAPHeaderBlock</CODE>
+ * object to be on or off. <P>If the mustUnderstand attribute is on, the
+ * actor who receives the <CODE>SOAPHeaderBlock</CODE> must process it
+ * correctly. This ensures, for example, that if the <CODE>
+ * SOAPHeaderBlock</CODE> object modifies the message, that the message is
+ * being modified correctly.</P>
+ *
+ * @param mustUnderstand <CODE>true</CODE> to set the mustUnderstand
+ * attribute on; <CODE>false</CODE> to turn if off
+ * @throws java.lang.IllegalArgumentException
+ * if there is a problem in setting the actor.
+ * @see #getMustUnderstand() getMustUnderstand()
+ */
+ public abstract void setMustUnderstand(boolean mustUnderstand);
+
+ public abstract void setMustUnderstand(String mustUnderstand) throws SOAPProcessingException;
+
+ /**
+ * Returns whether the mustUnderstand attribute for this
+ * <CODE>SOAPHeaderBlock</CODE> object is turned on.
+ *
+ * @return <CODE>true</CODE> if the mustUnderstand attribute of this
+ * <CODE>SOAPHeaderBlock</CODE> object is turned on;
+ * <CODE>false</CODE> otherwise
+ */
+ public abstract boolean getMustUnderstand() throws SOAPProcessingException;
+
+
+ public abstract boolean isProcessed();
+
+ /**
+ * We need to know whether all the mustUnderstand headers have been
+ * processed by the node. This will done by a specific validation handler at
+ * the end of the execution chain. For this all the handlers who process a
+ * particular header block must explicitly say that he processesd the header
+ * by calling setProcessed()
+ */
+ public abstract void setProcessed();
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPMessage.java b/src/org/apache/ws/commons/soap/SOAPMessage.java
new file mode 100644
index 0000000..ba1b1ee
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPMessage.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMDocument;
+
+public interface SOAPMessage extends OMDocument {
+
+ public SOAPEnvelope getSOAPEnvelope() throws SOAPProcessingException;
+ public void setSOAPEnvelope(SOAPEnvelope envelope) throws SOAPProcessingException;
+
+}
diff --git a/src/org/apache/ws/commons/soap/SOAPProcessingException.java b/src/org/apache/ws/commons/soap/SOAPProcessingException.java
new file mode 100644
index 0000000..b7c06eb
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/SOAPProcessingException.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMException;
+
+public class SOAPProcessingException extends OMException {
+
+ private String soapFaultCode;
+
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public SOAPProcessingException(String message) {
+ super(message);
+ }
+
+ public SOAPProcessingException(Throwable cause) {
+ super(cause);
+ }
+
+ /**
+ *
+ * @param messageText - this will appear as the Text in the Reason information item of SOAP Fault
+ * @param faultCode - this will appear as the Value in the Code information item of SOAP Fault
+ * @param cause - this will appear under the Detail information item of SOAP Fault
+ */
+ public SOAPProcessingException(String messageText, String faultCode, Throwable cause) {
+ super(messageText, cause);
+ this.soapFaultCode = faultCode;
+ }
+
+ /**
+ *
+ * @param messageText - this will appear as the Text in the Reason information item of SOAP Fault
+ * @param faultCode - this will appear as the Value in the Code information item of SOAP Fault
+ */
+ public SOAPProcessingException(String messageText, String faultCode) {
+ super(messageText);
+ this.soapFaultCode = faultCode;
+ }
+
+ public String getFaultCode() {
+ return soapFaultCode;
+ }
+
+ public void setFaultCode(String soapFaultCode) {
+ this.soapFaultCode = soapFaultCode;
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPBodyImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPBodyImpl.java
new file mode 100644
index 0000000..3c249e0
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPBodyImpl.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+/**
+ * Class SOAPBodyImpl
+ */
+public abstract class SOAPBodyImpl extends SOAPElement
+ implements SOAPBody, OMConstants {
+ /**
+ * Field hasSOAPFault
+ */
+ private boolean hasSOAPFault = false;
+
+ /**
+ * @param envelope
+ */
+ public SOAPBodyImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope, SOAPConstants.BODY_LOCAL_NAME, true);
+
+ }
+
+ /**
+ * Constructor SOAPBodyImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAPBodyImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, SOAPConstants.BODY_LOCAL_NAME, builder);
+ }
+
+ /**
+ * Creates a new <code>SOAPFault</code> object and adds it to
+ * this <code>SOAPBody</code> object.
+ *
+ * @param e
+ * @return the new <code>SOAPFault</code> object
+ * @throws org.apache.ws.commons.om.OMException
+ * if there is a SOAP error
+ * @throws OMException
+ */
+ public abstract SOAPFault addFault(Exception e) throws OMException;
+
+ /**
+ * Indicates whether a <code>SOAPFault</code> object exists in
+ * this <code>SOAPBody</code> object.
+ *
+ * @return <code>true</code> if a <code>SOAPFault</code> object exists in
+ * this <code>SOAPBody</code> object; <code>false</code>
+ * otherwise
+ */
+ public boolean hasFault() {
+ if (hasSOAPFault) {
+ return true;
+ } else {
+ OMElement element = getFirstElement();
+ if (element != null
+ &&
+ SOAPConstants.SOAPFAULT_LOCAL_NAME.equals(
+ element.getLocalName())
+ &&
+ (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(
+ element.getNamespace().getName())
+ ||
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(
+ element.getNamespace().getName()))) { //added this line
+ hasSOAPFault = true;
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Returns the <code>SOAPFault</code> object in this <code>SOAPBody</code>
+ * object.
+ *
+ * @return the <code>SOAPFault</code> object in this <code>SOAPBody</code>
+ * object
+ */
+ public SOAPFault getFault() {
+ OMElement element = getFirstElement();
+ if (hasSOAPFault) {
+ return (SOAPFault) element;
+ } else if (element != null
+ &&
+ SOAPConstants.SOAPFAULT_LOCAL_NAME.equals(
+ element.getLocalName())
+ &&
+ (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(
+ element.getNamespace().getName())
+ ||
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(
+ element.getNamespace().getName()))) { //added this line
+ hasSOAPFault = true;
+ return (SOAPFault) element;
+ } else {
+ return null;
+ }
+
+ }
+
+ /**
+ * @param soapFault
+ * @throws org.apache.ws.commons.om.OMException
+ *
+ * @throws OMException
+ */
+ public void addFault(SOAPFault soapFault) throws OMException {
+ if (hasSOAPFault) {
+ throw new OMException(
+ "SOAP Body already has a SOAP Fault and there can not be more than one SOAP fault");
+ }
+ addChild(soapFault);
+ hasSOAPFault = true;
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAPEnvelopeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting an implementation of SOAP Envelope as the parent. But received some other implementation");
+ }
+ }
+
+ public OMNode detach() throws OMException {
+ throw new SOAPProcessingException("Can not detach SOAP Body, SOAP Envelope must have a Body !!");
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPElement.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPElement.java
new file mode 100644
index 0000000..0128018
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPElement.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMElementImpl;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+public abstract class SOAPElement extends OMElementImpl {
+
+
+ /**
+ * @param parent
+ * @param localName
+ * @param extractNamespaceFromParent
+ */
+ protected SOAPElement(OMElement parent,
+ String localName,
+ boolean extractNamespaceFromParent) throws SOAPProcessingException {
+ super(localName, null, parent);
+ if (parent == null) {
+ throw new SOAPProcessingException(
+ " Can not create " + localName +
+ " element without a parent !!");
+ }
+ checkParent(parent);
+
+ if (extractNamespaceFromParent) {
+ this.ns = parent.getNamespace();
+ }
+ this.localName = localName;
+ }
+
+
+ protected SOAPElement(OMElement parent,
+ String localName,
+ OMXMLParserWrapper builder) {
+ super(localName, null, parent, builder);
+ }
+
+ /**
+ * Caution : This Constructor is meant to be used only by the SOAPEnvelope.
+ * <p/>
+ * Reasons : This can be used to create a SOAP Element programmatically. But we need to make sure that the user
+ * always passes a parent for the element being created. But SOAP Envelope has no parent.
+ *
+ * @param localName
+ * @param ns
+ */
+ protected SOAPElement(String localName, OMNamespace ns) {
+ super(localName, ns);
+
+ }
+
+ /**
+ * This has to be implemented by all the derived classes to check for the correct parent.
+ */
+ protected abstract void checkParent(OMElement parent) throws SOAPProcessingException;
+
+
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPEnvelopeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPEnvelopeImpl.java
new file mode 100644
index 0000000..b2ae015
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPEnvelopeImpl.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.factory.SOAPLinkedListImplFactory;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+
+/**
+ * Class SOAPEnvelopeImpl
+ */
+public class SOAPEnvelopeImpl extends SOAPElement
+ implements SOAPEnvelope, OMConstants {
+ SOAPFactory factory;
+
+ /**
+ * @param builder
+ */
+ public SOAPEnvelopeImpl(OMXMLParserWrapper builder, SOAPFactory factory) {
+ super(null, SOAPConstants.SOAPENVELOPE_LOCAL_NAME, builder);
+ this.factory = factory;
+ }
+
+ /**
+ * @param ns
+ */
+ public SOAPEnvelopeImpl(OMNamespace ns, SOAPFactory factory) {
+ super(SOAPConstants.SOAPENVELOPE_LOCAL_NAME, ns);
+ this.factory = factory;
+ }
+
+ /**
+ * Returns the <CODE>SOAPHeader</CODE> object for this <CODE>
+ * SOAPEnvelope</CODE> object. <P> This SOAPHeader will just be a container
+ * for all the headers in the <CODE>OMMessage</CODE> </P>
+ *
+ * @return the <CODE>SOAPHeader</CODE> object or <CODE> null</CODE> if there
+ * is none
+ * @throws org.apache.ws.commons.om.OMException
+ * if there is a problem obtaining
+ * the <CODE>SOAPHeader</CODE>
+ * object
+ * @throws OMException
+ */
+ public SOAPHeader getHeader() throws OMException {
+ SOAPHeader header =
+ (SOAPHeader) getFirstChildWithName(
+ new QName(SOAPConstants.HEADER_LOCAL_NAME));
+ if (builder == null && header == null) {
+ inferFactory();
+ header = factory.createSOAPHeader(this);
+ addChild(header);
+ }
+ return header;
+ }
+
+ private void inferFactory() {
+ if (factory instanceof SOAPLinkedListImplFactory && ns != null) {
+ if (SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(ns.getName())) {
+ factory = OMAbstractFactory.getSOAP12Factory();
+ } else if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(ns.getName())) {
+ factory = OMAbstractFactory.getSOAP11Factory();
+ }
+ }
+ }
+
+ public void addChild(OMNode child) {
+ if ((child instanceof OMElement) && !(child instanceof SOAPHeader || child instanceof SOAPBody)) {
+ throw new SOAPProcessingException("SOAP Envelope can not have children other than SOAP Header and Body", SOAP12Constants.FAULT_CODE_SENDER);
+ } else {
+ super.addChild(child);
+ }
+ }
+
+ /**
+ * Returns the <CODE>SOAPBody</CODE> object associated with this
+ * <CODE>SOAPEnvelope</CODE> object. <P> This SOAPBody will just be a
+ * container for all the BodyElements in the <CODE>OMMessage</CODE> </P>
+ *
+ * @return the <CODE>SOAPBody</CODE> object for this <CODE>
+ * SOAPEnvelope</CODE> object or <CODE>null</CODE> if there is none
+ * @throws org.apache.ws.commons.om.OMException
+ * if there is a problem obtaining
+ * the <CODE>SOAPBody</CODE> object
+ * @throws OMException
+ */
+ public SOAPBody getBody() throws OMException {
+ //check for the first element
+ OMElement element = getFirstElement();
+ if (element != null) {
+ if (SOAPConstants.BODY_LOCAL_NAME.equals(element.getLocalName())) {
+ return (SOAPBody) element;
+ } else { // if not second element SHOULD be the body
+ OMNode node = element.getNextOMSibling();
+ while (node != null && node.getType() != OMNode.ELEMENT_NODE) {
+ node = node.getNextOMSibling();
+ }
+ element = (OMElement) node;
+
+ if (node != null &&
+ SOAPConstants.BODY_LOCAL_NAME.equals(element.getLocalName())) {
+ return (SOAPBody) element;
+ } else {
+ throw new OMException("SOAPEnvelope must contain a body element which is either first or second child element of the SOAPEnvelope.");
+ }
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Method detach
+ *
+ * @throws OMException
+ */
+ public OMNode detach() throws OMException {
+ throw new OMException("Root Element can not be detached");
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ // here do nothing as SOAPEnvelope doesn't have a parent !!!
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ if (!omOutput.isIgnoreXMLDeclaration()) {
+ String charSetEncoding = omOutput.getCharSetEncoding();
+ String xmlVersion = omOutput.getXmlVersion();
+ omOutput.getXmlStreamWriter().writeStartDocument(charSetEncoding == null ?
+ OMConstants.DEFAULT_CHAR_SET_ENCODING : charSetEncoding,
+ xmlVersion == null ? OMConstants.DEFAULT_XML_VERSION : xmlVersion);
+ }
+ super.serialize(omOutput, cache);
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultCodeImpl.java
new file mode 100644
index 0000000..c2a77cc
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultCodeImpl.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.om.util.ElementHelper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+
+public abstract class SOAPFaultCodeImpl extends SOAPElement implements SOAPFaultCode {
+
+
+ /**
+ * Constructor OMElementImpl
+ *
+ * @param parent
+ * @param builder
+ */
+ public SOAPFaultCodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAPFaultCodeImpl(SOAPFault parent,
+ boolean extractNamespaceFromParent) throws SOAPProcessingException {
+ super(parent,
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME,
+ extractNamespaceFromParent);
+ }
+
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public void setValue(SOAPFaultValue value) throws SOAPProcessingException {
+ ElementHelper.setNewElement(this, value, value);
+ }
+
+ public SOAPFaultValue getValue() {
+ return (SOAPFaultValue) ElementHelper.getChildWithName(this,
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME);
+ }
+
+ public void setSubCode(SOAPFaultSubCode value) throws SOAPProcessingException {
+ ElementHelper.setNewElement(this, getSubCode(), value);
+ }
+
+ public SOAPFaultSubCode getSubCode() {
+ return (SOAPFaultSubCode) ElementHelper.getChildWithName(this,
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ if (!cache) {
+ //No caching
+ if (this.firstChild != null) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else if (!this.done) {
+ if (builderType == PULL_TYPE_BUILDER) {
+ OMSerializerUtil.serializeByPullStream(this, omOutput);
+ } else {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ builder.setCache(cache);
+ builder.next();
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+ } else {
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+ }
+ // do not serialise the siblings
+
+
+ } else {
+ //Cached
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+
+ // do not serialise the siblings
+ }
+
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultDetailImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultDetailImpl.java
new file mode 100644
index 0000000..9f273ac
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultDetailImpl.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+import java.util.Iterator;
+
+public abstract class SOAPFaultDetailImpl extends SOAPElement implements SOAPFaultDetail {
+
+ protected SOAPFaultDetailImpl(SOAPFault parent,
+ boolean extractNamespaceFromParent) throws SOAPProcessingException {
+ super(parent,
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME,
+ extractNamespaceFromParent);
+ }
+
+ protected SOAPFaultDetailImpl(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME, builder);
+ }
+
+ public void addDetailEntry(OMElement detailElement) {
+ this.addChild(detailElement);
+ }
+
+ public Iterator getAllDetailEntries() {
+ return this.getChildren();
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ if (!cache) {
+ //No caching
+ if (this.firstChild != null) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else if (!this.done) {
+ if (builderType == PULL_TYPE_BUILDER) {
+ OMSerializerUtil.serializeByPullStream(this, omOutput);
+ } else {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ builder.setCache(cache);
+ builder.next();
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+ } else {
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+ }
+ // do not serialise the siblings
+
+
+ } else {
+ //Cached
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+
+ // do not serialise the siblings
+ }
+
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultImpl.java
new file mode 100644
index 0000000..5ee20ec
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultImpl.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.OMElementImpl;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.util.Iterator;
+
+/**
+ * Class SOAPFaultImpl
+ */
+public abstract class SOAPFaultImpl extends SOAPElement
+ implements SOAPFault, OMConstants {
+
+ protected Exception e;
+ private Log log = LogFactory.getLog(getClass());
+
+ /**
+ * Constructor SOAPFaultImpl
+ *
+ * @param parent
+ * @param e
+ */
+ public SOAPFaultImpl(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ super(parent, SOAPConstants.SOAPFAULT_LOCAL_NAME, true);
+ setException(e);
+ }
+
+ public void setException(Exception e) {
+ this.e = e;
+ putExceptionToSOAPFault(e);
+ }
+
+ public SOAPFaultImpl(SOAPBody parent) throws SOAPProcessingException {
+ super(parent, SOAPConstants.SOAPFAULT_LOCAL_NAME, true);
+ }
+
+ /**
+ * Constructor SOAPFaultImpl
+ *
+ * @param parent
+ * @param builder
+ */
+ public SOAPFaultImpl(SOAPBody parent, OMXMLParserWrapper builder) {
+ super(parent, SOAPConstants.SOAPFAULT_LOCAL_NAME, builder);
+ }
+
+
+ protected abstract SOAPFaultDetail getNewSOAPFaultDetail(SOAPFault fault) throws SOAPProcessingException;
+
+ // --------------- Getters and Settors --------------------------- //
+
+ public void setCode(SOAPFaultCode soapFaultCode) throws SOAPProcessingException {
+ setNewElement(getCode(), soapFaultCode);
+ }
+
+ public SOAPFaultCode getCode() {
+ return (SOAPFaultCode) this.getChildWithName(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME);
+ }
+
+ public void setReason(SOAPFaultReason reason) throws SOAPProcessingException {
+ setNewElement(getReason(), reason);
+ }
+
+ public SOAPFaultReason getReason() {
+ return (SOAPFaultReason) this.getChildWithName(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME);
+ }
+
+ public void setNode(SOAPFaultNode node) throws SOAPProcessingException {
+ setNewElement(getNode(), node);
+ }
+
+ public SOAPFaultNode getNode() {
+ return (SOAPFaultNode) this.getChildWithName(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME);
+ }
+
+ public void setRole(SOAPFaultRole role) throws SOAPProcessingException {
+ setNewElement(getRole(), role);
+ }
+
+ public SOAPFaultRole getRole() {
+ return (SOAPFaultRoleImpl) this.getChildWithName(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME);
+ }
+
+ public void setDetail(SOAPFaultDetail detail) throws SOAPProcessingException {
+ setNewElement(getDetail(), detail);
+ }
+
+ public SOAPFaultDetail getDetail() {
+ return (SOAPFaultDetail) this.getChildWithName(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME);
+ }
+
+ /**
+ * If exception detailElement is not there we will return null
+ */
+ public Exception getException() throws OMException {
+ SOAPFaultDetail detail = getDetail();
+ if (detail == null) {
+ return null;
+ }
+
+ OMElement exceptionElement = getDetail().getFirstChildWithName(
+ new QName(SOAPConstants.SOAP_FAULT_DETAIL_EXCEPTION_ENTRY));
+ if (exceptionElement != null && exceptionElement.getText() != null) {
+ return new Exception(exceptionElement.getText());
+ }
+ return null;
+ }
+
+ protected void putExceptionToSOAPFault(Exception e) throws SOAPProcessingException {
+ StringWriter sw = new StringWriter();
+ e.printStackTrace(new PrintWriter(sw));
+ sw.flush();
+ getDetail();
+ if (getDetail() == null) {
+ setDetail(getNewSOAPFaultDetail(this));
+
+ }
+ OMElement faultDetailEnty = new OMElementImpl(
+ SOAPConstants.SOAP_FAULT_DETAIL_EXCEPTION_ENTRY,
+ this.getNamespace());
+ faultDetailEnty.setText(sw.getBuffer().toString());
+ getDetail().addChild(faultDetailEnty);
+ }
+
+ protected void setNewElement(OMElement myElement, OMElement newElement) {
+ if (myElement != null) {
+ myElement.discard();
+ }
+ if (newElement != null && newElement.getParent() != null) {
+ newElement.discard();
+ }
+ this.addChild(newElement);
+ myElement = newElement;
+ }
+
+ protected OMElement getChildWithName(String childName) {
+ Iterator childrenIter = getChildren();
+ while (childrenIter.hasNext()) {
+ OMNode node = (OMNode) childrenIter.next();
+ if (node.getType() == OMNode.ELEMENT_NODE &&
+ childName.equals(((OMElement) node).getLocalName())) {
+ return (OMElement) node;
+ }
+ }
+ return null;
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ // this is a special case. This fault element may contain its children in any order. But spec mandates a specific order
+ // the overriding of the method will facilitate that. Not sure this is the best method to do this :(
+ build();
+
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ SOAPFaultCode faultCode = getCode();
+ if (faultCode != null) {
+ ((OMNodeEx)faultCode).serialize(omOutput);
+ }
+ SOAPFaultReason faultReason = getReason();
+ if (faultReason != null) {
+ ((OMNodeEx)faultReason).serialize(omOutput);
+ }
+
+ serializeFaultNode(omOutput);
+
+ SOAPFaultRole faultRole = getRole();
+ if (faultRole != null) {
+ ((OMNodeEx)faultRole).serialize(omOutput);
+ }
+
+ SOAPFaultDetail faultDetail = getDetail();
+ if (faultDetail != null) {
+ ((OMNodeEx)faultDetail).serialize(omOutput);
+ }
+
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+
+ protected abstract void serializeFaultNode(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException;
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultNodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultNodeImpl.java
new file mode 100644
index 0000000..554c2cd
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultNodeImpl.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+
+public abstract class SOAPFaultNodeImpl extends SOAPElement implements SOAPFaultNode {
+
+ public SOAPFaultNodeImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME, true);
+ }
+
+ public SOAPFaultNodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME, builder);
+ }
+
+ public void setNodeValue(String uri) {
+ this.setText(uri);
+ }
+
+ public String getNodeValue() {
+ return this.getText();
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ if (!cache) {
+ //No caching
+ if (this.firstChild != null) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else if (!this.done) {
+ if (builderType == PULL_TYPE_BUILDER) {
+ OMSerializerUtil.serializeByPullStream(this, omOutput);
+ } else {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ builder.setCache(cache);
+ builder.next();
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+ } else {
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+ }
+ // do not serialise the siblings
+
+
+ } else {
+ //Cached
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+
+ // do not serialise the siblings
+ }
+
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultReasonImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultReasonImpl.java
new file mode 100644
index 0000000..f429a6e
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultReasonImpl.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.om.util.ElementHelper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+
+public abstract class SOAPFaultReasonImpl extends SOAPElement implements SOAPFaultReason {
+ protected SOAPFaultText text;
+
+ /**
+ * Constructor OMElementImpl
+ *
+ * @param parent
+ * @param builder
+ */
+ public SOAPFaultReasonImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAPFaultReasonImpl(OMElement parent,
+ boolean extractNamespaceFromParent) throws SOAPProcessingException {
+ super(parent,
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME,
+ extractNamespaceFromParent);
+ }
+
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public void setSOAPText(SOAPFaultText soapFaultText) throws SOAPProcessingException {
+ ElementHelper.setNewElement(this, text, soapFaultText);
+ }
+
+ public SOAPFaultText getSOAPText() {
+ return (SOAPFaultText) ElementHelper.getChildWithName(this,
+ SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME);
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ if (!cache) {
+ //No caching
+ if (this.firstChild != null) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else if (!this.done) {
+ if (builderType == PULL_TYPE_BUILDER) {
+ OMSerializerUtil.serializeByPullStream(this, omOutput);
+ } else {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ builder.setCache(cache);
+ builder.next();
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+ } else {
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+ }
+ // do not serialise the siblings
+
+
+ } else {
+ //Cached
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+
+ // do not serialise the siblings
+ }
+
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultRoleImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultRoleImpl.java
new file mode 100644
index 0000000..38d7b60
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultRoleImpl.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+
+public abstract class SOAPFaultRoleImpl extends SOAPElement implements org.apache.ws.commons.soap.SOAPFaultRole {
+
+ public SOAPFaultRoleImpl(SOAPFault parent,
+ boolean extractNamespaceFromParent) throws SOAPProcessingException {
+ super(parent,
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME,
+ extractNamespaceFromParent);
+ }
+
+ public SOAPFaultRoleImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME, builder);
+ }
+
+ public void setRoleValue(String uri) {
+ this.setText(uri);
+ }
+
+ public String getRoleValue() {
+ return this.getText();
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+
+ if (!cache) {
+ //No caching
+ if (this.firstChild != null) {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ OMSerializerUtil.serializeEndpart(omOutput);
+ } else if (!this.done) {
+ if (builderType == PULL_TYPE_BUILDER) {
+ OMSerializerUtil.serializeByPullStream(this, omOutput);
+ } else {
+ OMSerializerUtil.serializeStartpart(this, omOutput);
+ builder.setCache(cache);
+ builder.next();
+ OMSerializerUtil.serializeEndpart(omOutput);
+ }
+ } else {
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+ }
+ // do not serialise the siblings
+
+
+ } else {
+ //Cached
+ OMSerializerUtil.serializeNormal(this, omOutput, cache);
+
+ // do not serialise the siblings
+ }
+
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultSubCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultSubCodeImpl.java
new file mode 100644
index 0000000..02bc336
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultSubCodeImpl.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.util.ElementHelper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+public abstract class SOAPFaultSubCodeImpl extends SOAPElement implements SOAPFaultSubCode {
+
+ protected SOAPFaultValue value;
+ protected SOAPFaultSubCode subCode;
+
+
+ protected SOAPFaultSubCodeImpl(OMElement parent, String localName) throws SOAPProcessingException {
+ super(parent, localName, true);
+ }
+
+ protected SOAPFaultSubCodeImpl(OMElement parent,
+ String localName,
+ OMXMLParserWrapper builder) {
+ super(parent, localName, builder);
+ }
+
+ public void setValue(SOAPFaultValue soapFaultSubCodeValue) throws SOAPProcessingException {
+ ElementHelper.setNewElement(this, value, soapFaultSubCodeValue);
+ }
+
+ public SOAPFaultValue getValue() {
+ if (value == null) {
+ value =
+ (SOAPFaultValue) ElementHelper.getChildWithName(this,
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME);
+ }
+ return value;
+ }
+
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException {
+ ElementHelper.setNewElement(this, this.subCode, subCode);
+
+ }
+
+ public SOAPFaultSubCode getSubCode() {
+ if (subCode == null) {
+ subCode =
+ (SOAPFaultSubCode) ElementHelper.getChildWithName(this,
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+ return subCode;
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultTextImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultTextImpl.java
new file mode 100644
index 0000000..f5ad236
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultTextImpl.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMAttributeImpl;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.namespace.QName;
+
+public abstract class SOAPFaultTextImpl extends SOAPElement implements SOAPFaultText {
+ protected OMAttribute langAttr;
+ protected OMNamespace langNamespace = OMAbstractFactory.getOMFactory()
+ .createOMNamespace(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_URI,
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX);
+
+ protected SOAPFaultTextImpl(SOAPFaultReason parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME, true);
+ }
+
+ protected SOAPFaultTextImpl(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME, builder);
+ }
+
+
+ public void setLang(String lang) {
+ //langAttr = new OMAttributeImpl(SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME, parent.getNamespace(), lang);
+ langAttr =
+ new OMAttributeImpl(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME,
+ langNamespace,
+ lang);
+ this.addAttribute(langAttr);
+ }
+
+ public String getLang() {
+ if (langAttr == null) {
+ //langAttr = this.getFirstAttribute(new QName(SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME, parent.getNamespace().getName()));
+ langAttr =
+ this.getAttribute(
+ new QName(langNamespace.getName(),
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME,
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX));
+ }
+
+ return langAttr == null ? null : langAttr.getAttributeValue();
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultValueImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultValueImpl.java
new file mode 100644
index 0000000..7da4ee2
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPFaultValueImpl.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+public abstract class SOAPFaultValueImpl extends SOAPElement implements SOAPFaultValue {
+
+ protected SOAPFaultValueImpl(OMElement parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME, true);
+ }
+
+ protected SOAPFaultValueImpl(OMElement parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME, builder);
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderBlockImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderBlockImpl.java
new file mode 100644
index 0000000..307c57c
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderBlockImpl.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMAttributeImpl;
+import org.apache.ws.commons.om.impl.llom.OMElementImpl;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.namespace.QName;
+
+/**
+ * Class SOAPHeaderBlockImpl
+ */
+public abstract class SOAPHeaderBlockImpl extends OMElementImpl
+ implements SOAPHeaderBlock {
+
+ private boolean processed = false;
+
+ /**
+ * @param localName
+ * @param ns
+ * @param parent
+ */
+ public SOAPHeaderBlockImpl(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ super(localName, ns, parent);
+ this.setNamespace(ns);
+ }
+
+ /**
+ * Constructor SOAPHeaderBlockImpl.
+ *
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ */
+ public SOAPHeaderBlockImpl(String localName, OMNamespace ns,
+ OMElement parent, OMXMLParserWrapper builder) {
+ super(localName, ns, parent, builder);
+ this.setNamespace(ns);
+ }
+
+ /**
+ * @param attributeName
+ * @param attrValue
+ * @param soapEnvelopeNamespaceURI
+ */
+ protected void setAttribute(String attributeName,
+ String attrValue,
+ String soapEnvelopeNamespaceURI) {
+ OMAttribute omAttribute = this.getAttribute(
+ new QName(soapEnvelopeNamespaceURI, attributeName));
+ if (omAttribute != null) {
+ omAttribute.setAttributeValue(attrValue);
+ } else {
+ OMAttribute attribute = new OMAttributeImpl(attributeName,
+ new OMNamespaceImpl(soapEnvelopeNamespaceURI,
+ SOAPConstants.SOAP_DEFAULT_NAMESPACE_PREFIX),
+ attrValue);
+ this.addAttribute(attribute);
+ }
+ }
+
+ /**
+ * Method getAttribute.
+ *
+ * @param attrName
+ * @param soapEnvelopeNamespaceURI
+ * @return Returns String.
+ */
+ protected String getAttribute(String attrName,
+ String soapEnvelopeNamespaceURI) {
+ OMAttribute omAttribute = this.getAttribute(
+ new QName(soapEnvelopeNamespaceURI, attrName));
+ return (omAttribute != null)
+ ? omAttribute.getAttributeValue()
+ : null;
+ }
+
+ public boolean isProcessed() {
+ return processed;
+ }
+
+ public void setProcessed() {
+ processed = true;
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderImpl.java
new file mode 100644
index 0000000..0cdb128
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPHeaderImpl.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+/**
+ * Class SOAPHeaderImpl
+ */
+public abstract class SOAPHeaderImpl extends SOAPElement implements SOAPHeader {
+ /**
+ * @param envelope
+ */
+ public SOAPHeaderImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope, SOAPConstants.HEADER_LOCAL_NAME, true);
+
+ }
+
+ /**
+ * Constructor SOAPHeaderImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAPHeaderImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, SOAPConstants.HEADER_LOCAL_NAME, builder);
+ }
+
+ /**
+ * Creates a new <CODE>SOAPHeaderBlock</CODE> object initialized with the
+ * specified name and adds it to this <CODE>SOAPHeader</CODE> object.
+ *
+ * @param localName
+ * @param ns
+ * @return the new <CODE>SOAPHeaderBlock</CODE> object that was inserted
+ * into this <CODE>SOAPHeader</CODE> object
+ * @throws org.apache.ws.commons.om.OMException
+ * if a SOAP error occurs
+ * @throws OMException
+ */
+ public abstract SOAPHeaderBlock addHeaderBlock(String localName,
+ OMNamespace ns)
+ throws OMException;
+
+ /**
+ * Returns a list of all the <CODE>SOAPHeaderBlock</CODE> objects in this
+ * <CODE>SOAPHeader</CODE> object that have the the specified actor. An
+ * actor is a global attribute that indicates the intermediate parties to
+ * whom the message should be sent. An actor receives the message and then
+ * sends it to the next actor. The default actor is the ultimate intended
+ * recipient for the message, so if no actor attribute is included in a
+ * <CODE>SOAPHeader</CODE> object, the message is sent to its ultimate
+ * destination.
+ *
+ * @param paramRole a <CODE>String</CODE> giving the URI of the actor for
+ * which to search
+ * @return an <CODE>Iterator</CODE> object over all the <CODE>
+ * SOAPHeaderBlock</CODE> objects that contain the specified actor
+ * @see #extractHeaderBlocks(String) extractHeaderBlocks(java.lang.String)
+ */
+ public Iterator examineHeaderBlocks(String paramRole) {
+ Iterator headerBlocksIter = this.getChildren();
+ ArrayList headersWithGivenActor = new ArrayList();
+
+ if(paramRole == null || "".equals(paramRole)){
+ return returnAllSOAPHeaders(this.getChildren());
+ }
+
+ while (headerBlocksIter.hasNext()) {
+ Object o = headerBlocksIter.next();
+ if (o instanceof SOAPHeaderBlock) {
+ SOAPHeaderBlock soapHeaderBlock = (SOAPHeaderBlock) o;
+ String role = soapHeaderBlock.getRole();
+ if ((role != null) && role.equalsIgnoreCase(paramRole)) {
+ headersWithGivenActor.add(soapHeaderBlock);
+ }
+ }
+ }
+ return headersWithGivenActor.iterator();
+ }
+
+ private Iterator returnAllSOAPHeaders(Iterator children) {
+ ArrayList headers = new ArrayList();
+ while (children.hasNext()) {
+ Object o = children.next();
+ if (o instanceof SOAPHeaderBlock) {
+ headers.add(o);
+ }
+ }
+
+ return headers.iterator();
+
+ }
+
+ /**
+ * Returns a list of all the <CODE>SOAPHeaderBlock</CODE> objects in this
+ * <CODE>SOAPHeader</CODE> object that have the the specified role and
+ * detaches them from this <CODE> SOAPHeader</CODE> object. <P>This method
+ * allows an role to process only the parts of the <CODE>SOAPHeader</CODE>
+ * object that apply to it and to remove them before passing the message on
+ * to the next role.
+ *
+ * @param role a <CODE>String</CODE> giving the URI of the role for which to
+ * search
+ * @return an <CODE>Iterator</CODE> object over all the <CODE>
+ * SOAPHeaderBlock</CODE> objects that contain the specified role
+ * @see #examineHeaderBlocks(String) examineHeaderBlocks(java.lang.String)
+ */
+ public abstract Iterator extractHeaderBlocks(String role);
+
+ /**
+ * Returns an <code>Iterator</code> over all the <code>SOAPHeaderBlock</code>
+ * objects in this <code>SOAPHeader</code> object that have the specified
+ * actor and that have a MustUnderstand attribute whose value is equivalent
+ * to <code>true</code>.
+ *
+ * @param actor a <code>String</code> giving the URI of the actor for which
+ * to search
+ * @return an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects that contain the specified
+ * actor and are marked as MustUnderstand
+ */
+ public Iterator examineMustUnderstandHeaderBlocks(String actor) {
+ Iterator headerBlocksIter = this.getChildren();
+ ArrayList mustUnderstandHeadersWithGivenActor = new ArrayList();
+ while (headerBlocksIter.hasNext()) {
+ Object o = headerBlocksIter.next();
+ if (o instanceof SOAPHeaderBlock) {
+ SOAPHeaderBlock soapHeaderBlock = (SOAPHeaderBlock) o;
+ String role = soapHeaderBlock.getRole();
+ boolean mustUnderstand = soapHeaderBlock.getMustUnderstand();
+ if ((role != null) && role.equalsIgnoreCase(actor) &&
+ mustUnderstand) {
+ mustUnderstandHeadersWithGivenActor.add(soapHeaderBlock);
+ }
+ }
+ }
+ return mustUnderstandHeadersWithGivenActor.iterator();
+ }
+
+ /**
+ * Returns an <code>Iterator</code> over all the <code>SOAPHeaderBlock</code>
+ * objects in this <code>SOAPHeader</code> object. Not that this will return
+ * elements containing the QName (http://schemas.xmlsoap.org/soap/envelope/,
+ * Header)
+ *
+ * @return an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects contained by this
+ * <code>SOAPHeader</code>
+ */
+ public Iterator examineAllHeaderBlocks() {
+ return this.getChildrenWithName(null);
+ }
+
+ /**
+ * Returns an <code>Iterator</code> over all the <code>SOAPHeaderBlock</code>
+ * objects in this <code>SOAPHeader </code> object and detaches them from
+ * this <code>SOAPHeader</code> object.
+ *
+ * @return an <code>Iterator</code> object over all the
+ * <code>SOAPHeaderBlock</code> objects contained by this
+ * <code>SOAPHeader</code>
+ */
+ public Iterator extractAllHeaderBlocks() {
+ throw new UnsupportedOperationException(); // TODO implement this
+ }
+
+ public ArrayList getHeaderBlocksWithNSURI(String nsURI) {
+ ArrayList headers = null;
+ OMNode node = null;
+ OMElement header = this.getFirstElement();
+
+ if (header != null) {
+ headers = new ArrayList();
+ }
+
+ node = header;
+
+ while (node != null) {
+ if (node.getType() == OMNode.ELEMENT_NODE) {
+ header = (OMElement) node;
+ if (nsURI.equals(header.getNamespace().getName())) {
+ headers.add(header);
+ }
+ }
+ node = node.getNextOMSibling();
+
+ }
+ return headers;
+
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAPEnvelopeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting an implementation of SOAP Envelope as the parent. But received some other implementation");
+ }
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPMessageImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPMessageImpl.java
new file mode 100644
index 0000000..e793376
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPMessageImpl.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.OMDocumentImpl;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPMessage;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamException;
+
+public class SOAPMessageImpl extends OMDocumentImpl implements SOAPMessage {
+
+
+ public SOAPMessageImpl() {
+ }
+
+ public SOAPMessageImpl(SOAPEnvelope envelope, OMXMLParserWrapper parserWrapper) {
+ super(envelope, parserWrapper);
+ }
+
+ public SOAPMessageImpl(OMXMLParserWrapper parserWrapper) {
+ super(parserWrapper);
+ }
+
+
+ public SOAPEnvelope getSOAPEnvelope() throws SOAPProcessingException {
+ return (SOAPEnvelope) getOMDocumentElement();
+ }
+
+ public void setSOAPEnvelope(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super.addChild(envelope);
+ this.documentElement = envelope;
+ }
+
+ public void setOMDocumentElement(OMElement rootElement) {
+ throw new UnsupportedOperationException("This is not allowed. Use set SOAPEnvelope instead");
+ }
+
+ public void setFirstChild(OMNode firstChild) {
+ throw new UnsupportedOperationException("This is not allowed. Use set SOAPEnvelope instead");
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache, boolean includeXMLDeclaration) throws XMLStreamException {
+ if (cache) {
+ ((OMNodeEx)this.documentElement).serialize(omOutput);
+ } else {
+ ((OMNodeEx)this.documentElement).serializeAndConsume(omOutput);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/SOAPTextImpl.java b/src/org/apache/ws/commons/soap/impl/llom/SOAPTextImpl.java
new file mode 100644
index 0000000..8a13736
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/SOAPTextImpl.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+public class SOAPTextImpl extends SOAPElement {
+
+ protected SOAPTextImpl(OMElement parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME, true);
+ }
+
+ protected SOAPTextImpl(OMElement parent, OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME, builder);
+ }
+
+ public void setLang(String lang) {
+ // TODO : Chinthaka fix me
+ }
+
+ public String getLang() {
+ // TODO Chinthaka fix me
+ return null;
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ // do nothing
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP11BuilderHelper.java b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP11BuilderHelper.java
new file mode 100644
index 0000000..9eb96fd
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP11BuilderHelper.java
@@ -0,0 +1,174 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.exception.OMBuilderException;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.w3c.dom.Element;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+public class SOAP11BuilderHelper extends SOAPBuilderHelper implements SOAP11Constants {
+ private SOAPFactory factory;
+ private boolean faultcodePresent = false;
+ private boolean faultstringPresent = false;
+
+ private OMElement lastProcessedSOAPElement;
+
+ public SOAP11BuilderHelper(StAXSOAPModelBuilder builder) {
+ super(builder);
+ factory = builder.getSoapFactory();
+ }
+
+ public OMElement handleEvent(XMLStreamReader parser,
+ OMElement parent,
+ int elementLevel) throws SOAPProcessingException {
+ this.parser = parser;
+
+ OMElement element = null;
+ String localName = parser.getLocalName();
+
+ if (elementLevel == 4) {
+
+ if (SOAP_FAULT_CODE_LOCAL_NAME.equals(localName)) {
+ if (faultstringPresent) {
+ builder.setBooleanProcessingMandatoryFaultElements(false);
+ }
+ SOAPFaultCode code = factory.createSOAPFaultCode(
+ (SOAPFault) parent, builder);
+ SOAPFaultValue value = factory.createSOAPFaultValue(code);
+ processNamespaceData(code, true);
+ processAttributes(code);
+
+ processText(parser, value);
+ ((OMNodeEx)code).setComplete(true);
+ element = code;
+ builder.elementLevel--;
+
+ faultcodePresent = true;
+ } else if (SOAP_FAULT_STRING_LOCAL_NAME.equals(localName)) {
+ if (faultcodePresent) {
+ builder.setBooleanProcessingMandatoryFaultElements(false);
+ }
+
+
+ SOAPFaultReason reason = factory.createSOAPFaultReason(
+ (SOAPFault) parent, builder);
+ SOAPFaultText faultText = factory.createSOAPFaultText(reason);
+ processNamespaceData(reason, true);
+ processAttributes(reason);
+
+ processText(parser, faultText);
+ ((OMNodeEx)reason).setComplete(true);
+ element = reason;
+ builder.elementLevel--;
+
+
+ faultstringPresent = true;
+ } else if (SOAP_FAULT_ACTOR_LOCAL_NAME.equals(localName)) {
+ element =
+ factory.createSOAPFaultRole((SOAPFault) parent,
+ builder);
+ processNamespaceData(element, true);
+ processAttributes(element);
+ } else if (SOAP_FAULT_DETAIL_LOCAL_NAME.equals(localName)) {
+ element =
+ factory.createSOAPFaultDetail((SOAPFault) parent,
+ builder);
+ processNamespaceData(element, true);
+ processAttributes(element);
+ } else {
+ element =
+ factory.createOMElement(
+ localName, null, parent, builder);
+ processNamespaceData(element, false);
+ processAttributes(element);
+ }
+
+ } else if (elementLevel == 5) {
+
+ String parentTagName = "";
+ if(parent instanceof Element) {
+ parentTagName = ((Element)parent).getTagName();
+ } else {
+ parentTagName = parent.getLocalName();
+ }
+
+ if (parentTagName.equals(SOAP_FAULT_CODE_LOCAL_NAME)) {
+ throw new OMBuilderException(
+ "faultcode element should not have children");
+ } else if (parentTagName.equals(
+ SOAP_FAULT_STRING_LOCAL_NAME)) {
+ throw new OMBuilderException(
+ "faultstring element should not have children");
+ } else if (parentTagName.equals(
+ SOAP_FAULT_ACTOR_LOCAL_NAME)) {
+ throw new OMBuilderException(
+ "faultactor element should not have children");
+ } else {
+ element =
+ this.factory.createOMElement(
+ localName, null, parent, builder);
+ processNamespaceData(element, false);
+ processAttributes(element);
+ }
+
+ } else if (elementLevel > 5) {
+ element =
+ this.factory.createOMElement(localName,
+ null,
+ parent,
+ builder);
+ processNamespaceData(element, false);
+ processAttributes(element);
+ }
+
+ return element;
+ }
+
+ private void processText(XMLStreamReader parser, OMElement value) {
+ try {
+ int token = parser.next();
+ while (token != XMLStreamReader.END_ELEMENT) {
+ if (token == XMLStreamReader.CHARACTERS) {
+ OMText text = factory.createText(value, parser.getText());
+ value.addChild(text);
+ } else {
+ throw new SOAPProcessingException(
+ "Only Characters are allowed here");
+ }
+ token = parser.next();
+ }
+
+
+ } catch (XMLStreamException e) {
+ throw new SOAPProcessingException(e);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP12BuilderHelper.java b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP12BuilderHelper.java
new file mode 100644
index 0000000..c2c1724
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAP12BuilderHelper.java
@@ -0,0 +1,321 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.builder;
+
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.exception.OMBuilderException;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamReader;
+import java.util.Vector;
+
+public class SOAP12BuilderHelper extends SOAPBuilderHelper {
+
+ private SOAPFactory factory;
+ private boolean codePresent = false;
+ private boolean reasonPresent = false;
+ private boolean nodePresent = false;
+ private boolean rolePresent = false;
+ private boolean detailPresent = false;
+ private boolean subcodeValuePresent = false;
+ private boolean subSubcodePresent = false;
+ private boolean valuePresent = false;
+ private boolean subcodePresent = false;
+ private boolean codeprocessing = false;
+ private boolean subCodeProcessing = false;
+ private boolean reasonProcessing = false;
+ private Vector detailElementNames;
+
+ public SOAP12BuilderHelper(StAXSOAPModelBuilder builder) {
+ super(builder);
+ factory = builder.getSoapFactory();
+ }
+
+ public OMElement handleEvent(XMLStreamReader parser,
+ OMElement parent,
+ int elementLevel) throws SOAPProcessingException {
+
+ this.parser = parser;
+ OMElement element = null;
+
+ if (elementLevel == 4) {
+ if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME)) {
+ if (codePresent) {
+ throw new OMBuilderException(
+ "Multiple Code element encountered");
+ } else {
+ element =
+ factory.createSOAPFaultCode((SOAPFault) parent,
+ builder);
+ codePresent = true;
+ codeprocessing = true;
+ }
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME)) {
+ if (!codeprocessing && !subCodeProcessing) {
+ if (codePresent) {
+ if (reasonPresent) {
+ throw new OMBuilderException(
+ "Multiple Reason Element encountered");
+ } else {
+ element =
+ factory.createSOAPFaultReason(
+ (SOAPFault) parent, builder);
+ reasonPresent = true;
+ reasonProcessing = true;
+ }
+ } else {
+ throw new OMBuilderException(
+ "Wrong element order encountred at " +
+ parser.getLocalName());
+ }
+ } else {
+ if (codeprocessing) {
+ throw new OMBuilderException(
+ "Code doesn't have a value");
+ } else {
+ throw new OMBuilderException(
+ "A subcode doesn't have a Value");
+ }
+ }
+
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME)) {
+ if (!reasonProcessing) {
+ if (reasonPresent && !rolePresent && !detailPresent) {
+ if (nodePresent) {
+ throw new OMBuilderException(
+ "Multiple Node element encountered");
+ } else {
+ element =
+ factory.createSOAPFaultNode(
+ (SOAPFault) parent, builder);
+ nodePresent = true;
+ }
+ } else {
+ throw new OMBuilderException(
+ "wrong element order encountered at " +
+ parser.getLocalName());
+ }
+ } else {
+ throw new OMBuilderException(
+ "Reason element Should have a text");
+ }
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME)) {
+ if (!reasonProcessing) {
+ if (reasonPresent && !detailPresent) {
+ if (rolePresent) {
+ throw new OMBuilderException(
+ "Multiple Role element encountered");
+ } else {
+ element =
+ factory.createSOAPFaultRole(
+ (SOAPFault) parent, builder);
+ rolePresent = true;
+ }
+ } else {
+ throw new OMBuilderException(
+ "Wrong element order encountered at " +
+ parser.getLocalName());
+ }
+ } else {
+ throw new OMBuilderException(
+ "Reason element should have a text");
+ }
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME)) {
+ if (!reasonProcessing) {
+ if (reasonPresent) {
+ if (detailPresent) {
+ throw new OMBuilderException(
+ "Multiple detail element encountered");
+ } else {
+ element =
+ factory.createSOAPFaultDetail(
+ (SOAPFault) parent, builder);
+ detailPresent = true;
+ }
+ } else {
+ throw new OMBuilderException(
+ "wrong element order encountered at " +
+ parser.getLocalName());
+ }
+ } else {
+ throw new OMBuilderException(
+ "Reason element should have a text");
+ }
+ } else {
+ throw new OMBuilderException(
+ parser.getLocalName() +
+ " unsupported element in SOAPFault element");
+ }
+
+ } else if (elementLevel == 5) {
+ if (parent.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME)) {
+ if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME)) {
+ if (!valuePresent) {
+ element =
+ factory.createSOAPFaultValue(
+ (SOAPFaultCode) parent, builder);
+ valuePresent = true;
+ codeprocessing = false;
+ } else {
+ throw new OMBuilderException(
+ "Multiple value Encountered in code element");
+ }
+
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME)) {
+ if (!subcodePresent) {
+ if (valuePresent) {
+ element =
+ factory.createSOAPFaultSubCode(
+ (SOAPFaultCode) parent, builder);
+ subcodePresent = true;
+ subCodeProcessing = true;
+ } else {
+ throw new OMBuilderException(
+ "Value should present before the subcode");
+ }
+
+ } else {
+ throw new OMBuilderException(
+ "multiple subcode Encountered in code element");
+ }
+ } else {
+ throw new OMBuilderException(
+ parser.getLocalName() +
+ " is not supported inside the code element");
+ }
+
+ } else if (parent.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME)) {
+ if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME)) {
+ element =
+ factory.createSOAPFaultText(
+ (SOAPFaultReason) parent, builder);
+ ((OMNodeEx)element).setComplete(false);
+ reasonProcessing = false;
+ builder.setBooleanProcessingMandatoryFaultElements(false);
+ } else {
+ throw new OMBuilderException(
+ parser.getLocalName() +
+ " is not supported inside the reason");
+ }
+ } else if (parent.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME)) {
+ element =
+ this.factory.createOMElement(
+ parser.getLocalName(), null, parent, builder);
+ builder.setProcessingDetailElements(true);
+ detailElementNames = new Vector();
+ detailElementNames.add(parser.getLocalName());
+
+ } else {
+ throw new OMBuilderException(
+ parent.getLocalName() +
+ " should not have child element");
+ }
+
+
+ } else if (elementLevel > 5) {
+ if (parent.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME)) {
+ if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME)) {
+ if (subcodeValuePresent) {
+ throw new OMBuilderException(
+ "multiple subCode value encountered");
+ } else {
+ element =
+ factory.createSOAPFaultValue(
+ (SOAPFaultSubCode) parent, builder);
+ subcodeValuePresent = true;
+ subSubcodePresent = false;
+ subCodeProcessing = false;
+ }
+ } else if (parser.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME)) {
+ if (subcodeValuePresent) {
+ if (!subSubcodePresent) {
+ element =
+ factory.createSOAPFaultSubCode(
+ (SOAPFaultSubCode) parent,
+ builder);
+ subcodeValuePresent = false;
+ subSubcodePresent = true;
+ subCodeProcessing = true;
+ } else {
+ throw new OMBuilderException(
+ "multiple subcode encountered");
+ }
+ } else {
+ throw new OMBuilderException(
+ "Value should present before the subcode");
+ }
+ } else {
+ throw new OMBuilderException(
+ parser.getLocalName() +
+ " is not supported inside the subCode element");
+ }
+ } else if (builder.isProcessingDetailElements()) {
+ int detailElementLevel = 0;
+ boolean localNameExist = false;
+ for (int i = 0; i < detailElementNames.size(); i++) {
+ if (parent.getLocalName().equals(
+ detailElementNames.get(i))) {
+ localNameExist = true;
+ detailElementLevel = i + 1;
+ }
+ }
+ if (localNameExist) {
+ detailElementNames.setSize(detailElementLevel);
+ element =
+ this.factory.createOMElement(
+ parser.getLocalName(),
+ null,
+ parent,
+ builder);
+ detailElementNames.add(parser.getLocalName());
+ }
+
+ } else {
+ throw new OMBuilderException(
+ parent.getLocalName() +
+ " should not have child at element level " +
+ elementLevel);
+ }
+ }
+
+ processNamespaceData(element, false);
+ processAttributes(element);
+ return element;
+ }
+}
\ No newline at end of file
diff --git a/src/org/apache/ws/commons/soap/impl/llom/builder/SOAPBuilderHelper.java b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAPBuilderHelper.java
new file mode 100644
index 0000000..040ba25
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/builder/SOAPBuilderHelper.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.impl.llom.exception.OMBuilderException;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+
+import javax.xml.stream.XMLStreamReader;
+
+public abstract class SOAPBuilderHelper {
+ protected StAXSOAPModelBuilder builder;
+ protected XMLStreamReader parser;
+
+ protected SOAPBuilderHelper(StAXSOAPModelBuilder builder) {
+ this.builder = builder;
+ }
+
+ public abstract OMElement handleEvent(XMLStreamReader parser,
+ OMElement element,
+ int elementLevel) throws SOAPProcessingException;
+
+ protected void processNamespaceData(OMElement node, boolean isSOAPElement) {
+ int namespaceCount = parser.getNamespaceCount();
+ for (int i = 0; i < namespaceCount; i++) {
+ node.declareNamespace(parser.getNamespaceURI(i),
+ parser.getNamespacePrefix(i));
+ }
+
+ // set the own namespace
+ String namespaceURI = parser.getNamespaceURI();
+ String prefix = parser.getPrefix();
+ OMNamespace namespace = null;
+ if (namespaceURI != null && namespaceURI.length() > 0) {
+ if (prefix == null) {
+ // this means, this elements has a default namespace or it has inherited a default namespace from its parent
+ namespace = node.findNamespace(namespaceURI, "");
+ if (namespace == null) {
+ namespace = node.declareNamespace(namespaceURI, "");
+ }
+ } else {
+ namespace = node.findNamespace(namespaceURI, prefix);
+ }
+ node.setNamespace(namespace);
+ } else {
+
+ }
+
+
+
+ // TODO we got to have this to make sure OM reject mesagess that are not name space qualified
+ // But got to comment this to interop with Axis.1.x
+ // if (namespace == null) {
+ // throw new OMException("All elements must be namespace qualified!");
+ // }
+ if (isSOAPElement) {
+ if (node.getNamespace() != null &&
+ !node.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI) &&
+ !node.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI)) {
+ throw new OMBuilderException("invalid SOAP namespace URI");
+ }
+ }
+
+ }
+
+ protected void processAttributes(OMElement node) {
+ int attribCount = parser.getAttributeCount();
+ for (int i = 0; i < attribCount; i++) {
+ OMNamespace ns = null;
+ String uri = parser.getAttributeNamespace(i);
+ if (uri.hashCode() != 0) {
+ ns = node.findNamespace(uri,
+ parser.getAttributePrefix(i));
+ }
+
+ // todo if the attributes are supposed to namespace qualified all the time
+ // todo then this should throw an exception here
+ node.addAttribute(parser.getAttributeLocalName(i),
+ parser.getAttributeValue(i), ns);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilder.java b/src/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilder.java
new file mode 100644
index 0000000..fbefe39
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilder.java
@@ -0,0 +1,427 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.builder;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPMessage;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.stream.XMLStreamReader;
+
+/**
+ * Class StAXSOAPModelBuilder
+ */
+public class StAXSOAPModelBuilder extends StAXOMBuilder {
+
+ SOAPMessage soapMessage;
+ /**
+ * Field envelope
+ */
+ private SOAPEnvelope envelope;
+ private OMNamespace envelopeNamespace;
+
+
+ private SOAPFactory soapFactory;
+
+ /**
+ * Field headerPresent
+ */
+ private boolean headerPresent = false;
+
+ /**
+ * Field bodyPresent
+ */
+ private boolean bodyPresent = false;
+
+ /**
+ * Field log
+ */
+ private Log log = LogFactory.getLog(getClass());
+
+ /**
+ * element level 1 = envelope level element level 2 = Header or Body level
+ * element level 3 = HeaderElement or BodyElement level
+ */
+ protected int elementLevel = 0;
+
+ private boolean processingFault = false;
+
+
+ //added
+ /* This is used to indicate whether detail element is processing in soap 1.2 builderhelper
+ */
+ private boolean processingDetailElements = false;
+
+ private SOAPBuilderHelper builderHelper;
+ private String senderfaultCode;
+ private String receiverfaultCode;
+ private boolean processingMandatoryFaultElements;
+
+ // We need to have soap factory, temporary, until we find out the correct SOAP version. If user has not provided
+ // a SOAP factory, internally we are creating a default one. This flag will be set if we create one internally, to
+ // warn that this should be replaced later.
+ private boolean isTempSOAPFactory = true;
+
+ /**
+ * Constructor StAXSOAPModelBuilder
+ * soapVersion parameter is to give the soap version from the transport. For example, in HTTP case
+ * you can identify the version of the soap message u have recd by looking at the HTTP headers.
+ * It is used to check whether the actual soap message contained is of that version.
+ * If one is creates the builder from the transport, then can just pass null for version.
+ *
+ * @param parser
+ * @param soapVersion parameter is to give the soap version for the transport.
+ */
+ public StAXSOAPModelBuilder(XMLStreamReader parser, String soapVersion) {
+ super(parser);
+ soapFactory = OMAbstractFactory.getDefaultSOAPFactory();
+ isTempSOAPFactory = true;
+ soapMessage = soapFactory.createSOAPMessage(this);
+ this.document = soapMessage;
+ if(parser.getCharacterEncodingScheme() != null) {
+ document.setCharsetEncoding(parser.getCharacterEncodingScheme());
+ }
+ identifySOAPVersion(soapVersion);
+ }
+
+ /**
+ * @param parser
+ * @param factory
+ * @param soapVersion parameter is to give the soap version from the transport. For example, in
+ * HTTP case you can identify the version of the soap message u have recd by looking at
+ * the HTTP headers. It is used to check whether the actual soap message
+ * contained is of that version.If one is creates the builder from the transport,
+ * then can just pass null for version.
+ */
+ public StAXSOAPModelBuilder(XMLStreamReader parser, SOAPFactory factory, String soapVersion) {
+ super(factory, parser);
+ soapFactory = factory;
+ isTempSOAPFactory = false;
+ soapMessage = soapFactory.createSOAPMessage(this);
+ this.document = soapMessage;
+ identifySOAPVersion(soapVersion);
+ }
+
+ protected void identifySOAPVersion(String soapVersionURIFromTransport) {
+
+ SOAPEnvelope soapEnvelope = getSOAPEnvelope();
+ if (soapEnvelope == null) {
+ throw new SOAPProcessingException("SOAP Message does not contain an Envelope",
+ SOAPConstants.FAULT_CODE_VERSION_MISMATCH);
+ }
+
+ envelopeNamespace = soapEnvelope.getNamespace();
+ String namespaceName = envelopeNamespace.getName();
+ if ((soapVersionURIFromTransport != null) && !(soapVersionURIFromTransport.equals(namespaceName))) {
+ throw new SOAPProcessingException("Transport level information does not match with SOAP" +
+ " Message namespace URI", SOAPConstants.FAULT_CODE_VERSION_MISMATCH);
+
+ }
+ if(isTempSOAPFactory) {
+ if (SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(namespaceName)) {
+ soapFactory = OMAbstractFactory.getSOAP12Factory();
+ log.debug("Starting to process SOAP 1.2 message");
+ } else if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(namespaceName)) {
+ soapFactory = OMAbstractFactory.getSOAP11Factory();
+ log.debug("Starting to process SOAP 1.1 message");
+
+ } else {
+ throw new SOAPProcessingException("Only SOAP 1.1 or SOAP 1.2 messages are supported in the" +
+ " system", SOAPConstants.FAULT_CODE_VERSION_MISMATCH);
+ }
+ }
+ }
+
+ /**
+ * Method getSOAPEnvelope.
+ *
+ * @return Returns SOAPEnvelope.
+ * @throws OMException
+ */
+ public SOAPEnvelope getSOAPEnvelope() throws OMException {
+ while ((envelope == null) && !done) {
+ next();
+ }
+ return envelope;
+ }
+
+ /**
+ * Method createOMElement.
+ *
+ * @return Returns OMNode.
+ * @throws OMException
+ */
+ protected OMNode createOMElement() throws OMException {
+ elementLevel++;
+ OMElement node;
+ String elementName = parser.getLocalName();
+ if (lastNode == null) {
+ node = constructNode(null, elementName, true);
+ setSOAPEnvelope(node);
+ } else if (lastNode.isComplete()) {
+ node =
+ constructNode((OMElement) lastNode.getParent(),
+ elementName,
+ false);
+ ((OMNodeEx) lastNode).setNextOMSibling(node);
+ ((OMNodeEx) node).setPreviousOMSibling(lastNode);
+ } else {
+ OMElement e = (OMElement) lastNode;
+ node = constructNode((OMElement) lastNode, elementName, false);
+ e.setFirstChild(node);
+ }
+
+
+ log.debug("Build the OMElelment " + node.getLocalName() +
+ "By the StaxSOAPModelBuilder");
+ return node;
+ }
+
+ protected void setSOAPEnvelope(OMElement node) {
+ soapMessage.setSOAPEnvelope((SOAPEnvelope) node);
+ soapMessage.setXMLVersion(parser.getVersion());
+ soapMessage.setCharsetEncoding(parser.getCharacterEncodingScheme());
+ }
+
+ /**
+ * Method constructNode
+ *
+ * @param parent
+ * @param elementName
+ * @param isEnvelope
+ */
+ protected OMElement constructNode(OMElement parent, String elementName,
+ boolean isEnvelope) {
+ OMElement element = null;
+ if (parent == null) {
+ if (!elementName.equalsIgnoreCase(SOAPConstants.SOAPENVELOPE_LOCAL_NAME)) {
+ throw new SOAPProcessingException("First Element must contain the local name, "
+ + SOAPConstants.SOAPENVELOPE_LOCAL_NAME, SOAPConstants.FAULT_CODE_VERSION_MISMATCH);
+ }
+ envelope = soapFactory.createSOAPEnvelope(this);
+ element = envelope;
+ processNamespaceData(element, true);
+ // fill in the attributes
+ processAttributes(element);
+
+ } else if (elementLevel == 2) {
+
+ // this is either a header or a body
+ if (elementName.equals(SOAPConstants.HEADER_LOCAL_NAME)) {
+ if (headerPresent) {
+ throw new SOAPProcessingException("Multiple headers encountered!", getSenderFaultCode());
+ }
+ if (bodyPresent) {
+ throw new SOAPProcessingException("Header Body wrong order!", getSenderFaultCode());
+ }
+ headerPresent = true;
+ element =
+ soapFactory.createSOAPHeader((SOAPEnvelope) parent,
+ this);
+
+ processNamespaceData(element, true);
+ processAttributes(element);
+
+ } else if (elementName.equals(SOAPConstants.BODY_LOCAL_NAME)) {
+ if (bodyPresent) {
+ throw new SOAPProcessingException("Multiple body elements encountered", getSenderFaultCode());
+ }
+ bodyPresent = true;
+ element =
+ soapFactory.createSOAPBody((SOAPEnvelope) parent,
+ this);
+
+ processNamespaceData(element, true);
+ processAttributes(element);
+
+ } else {
+ throw new SOAPProcessingException(elementName
+ +
+ " is not supported here. Envelope can not have elements other than Header and Body.", getSenderFaultCode());
+ }
+ } else if ((elementLevel == 3)
+ &&
+ parent.getLocalName().equalsIgnoreCase(SOAPConstants.HEADER_LOCAL_NAME)) {
+
+ // this is a headerblock
+ try {
+ element =
+ soapFactory.createSOAPHeaderBlock(elementName, null,
+ (SOAPHeader) parent, this);
+ } catch (SOAPProcessingException e) {
+ throw new SOAPProcessingException("Can not create SOAPHeader block", getReceiverFaultCode(), e);
+ }
+ processNamespaceData(element, false);
+ processAttributes(element);
+
+ } else if ((elementLevel == 3) &&
+ parent.getLocalName().equalsIgnoreCase(SOAPConstants.BODY_LOCAL_NAME) &&
+ elementName.equalsIgnoreCase(SOAPConstants.BODY_FAULT_LOCAL_NAME)) {
+
+ // this is a headerblock
+ element = soapFactory.createSOAPFault((SOAPBody) parent, this);
+ processNamespaceData(element, false);
+ processAttributes(element);
+
+
+ processingFault = true;
+ processingMandatoryFaultElements = true;
+ if (SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(envelopeNamespace.getName())) {
+ builderHelper = new SOAP12BuilderHelper(this);
+ } else if (SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(envelopeNamespace.getName())) {
+ builderHelper = new SOAP11BuilderHelper(this);
+ }
+
+ } else if (elementLevel > 3 && processingFault) {
+ element = builderHelper.handleEvent(parser, parent, elementLevel);
+ } else {
+
+ // this is neither of above. Just create an element
+ element = soapFactory.createOMElement(elementName, null,
+ parent, this);
+ processNamespaceData(element, false);
+ processAttributes(element);
+
+ }
+ return element;
+ }
+
+ private String getSenderFaultCode() {
+ if (senderfaultCode == null) {
+ senderfaultCode = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(envelopeNamespace.getName()) ? SOAP12Constants.FAULT_CODE_SENDER : SOAP11Constants.FAULT_CODE_SENDER;
+ }
+ return senderfaultCode;
+ }
+
+ private String getReceiverFaultCode() {
+ if (receiverfaultCode == null) {
+ receiverfaultCode = SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI.equals(envelopeNamespace.getName()) ? SOAP12Constants.FAULT_CODE_RECEIVER : SOAP11Constants.FAULT_CODE_RECEIVER;
+ }
+ return receiverfaultCode;
+ }
+
+ public void endElement() {
+ if (lastNode.isComplete()) {
+ OMElement parent = (OMElement) lastNode.getParent();
+ ((OMNodeEx) parent).setComplete(true);
+ lastNode = parent;
+ } else {
+ OMNode e = lastNode;
+ ((OMNodeEx) e).setComplete(true);
+ }
+ elementLevel--;
+ }
+
+ /**
+ * Method createDTD.
+ * Overriding the default behaviour as a SOAPMessage should not have a DTD.
+ */
+ protected OMNode createDTD() throws OMException {
+ throw new OMException("SOAP message MUST NOT contain a Document Type Declaration(DTD)");
+ }
+
+ /**
+ * Method createPI.
+ * Overriding the default behaviour as a SOAP Message should not have a PI.
+ */
+ protected OMNode createPI() throws OMException {
+ throw new OMException("SOAP message MUST NOT contain Processing Instructions(PI)");
+ }
+
+ /**
+ * Method getDocumentElement.
+ *
+ * @return Returns OMElement.
+ */
+ public OMElement getDocumentElement() {
+ return getSOAPEnvelope();
+ }
+
+ /**
+ * Method processNamespaceData.
+ *
+ * @param node
+ * @param isSOAPElement
+ */
+ protected void processNamespaceData(OMElement node, boolean isSOAPElement) {
+
+ super.processNamespaceData(node, isSOAPElement);
+
+ if (isSOAPElement) {
+ if (node.getNamespace() != null &&
+ !node.getNamespace().getName().equals(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI) &&
+ !node.getNamespace().getName().equals(SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI)) {
+ throw new SOAPProcessingException("invalid SOAP namespace URI. " +
+ "Only " + SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI +
+ " and " + SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI +
+ " are supported.", SOAP12Constants.FAULT_CODE_SENDER);
+ }
+ }
+
+ }
+
+/*these three methods to set and check detail element processing or mandatory fault element are present
+*/
+
+ public OMNamespace getEnvelopeNamespace() {
+ return envelopeNamespace;
+ }
+
+ public void setBooleanProcessingMandatoryFaultElements(boolean value) {
+ this.processingMandatoryFaultElements = value;
+ }
+
+ public boolean isProcessingDetailElements() {
+ return processingDetailElements;
+ }
+
+ public void setProcessingDetailElements(boolean value) {
+ processingDetailElements = value;
+ }
+
+ public SOAPMessage getSoapMessage() {
+ return soapMessage;
+ }
+
+ public OMDocument getDocument() {
+ return (OMDocument) this.soapMessage;
+ }
+
+ /**
+ * @return Returns the soapFactory.
+ */
+ protected SOAPFactory getSoapFactory() {
+ return soapFactory;
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/factory/SOAPLinkedListImplFactory.java b/src/org/apache/ws/commons/soap/impl/llom/factory/SOAPLinkedListImplFactory.java
new file mode 100644
index 0000000..42ae89e
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/factory/SOAPLinkedListImplFactory.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.factory;
+
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMLinkedListImplFactory;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPMessage;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPEnvelopeImpl;
+import org.apache.ws.commons.soap.impl.llom.SOAPMessageImpl;
+
+public class SOAPLinkedListImplFactory extends OMLinkedListImplFactory implements SOAPFactory {
+ public String getSoapVersionURI() {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPMessage createSOAPMessage(OMXMLParserWrapper builder) {
+ return new SOAPMessageImpl(builder);
+ }
+
+
+ public SOAPMessage createSOAPMessage(SOAPEnvelope envelope, OMXMLParserWrapper parserWrapper) {
+ return new SOAPMessageImpl(envelope, parserWrapper);
+ }
+
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public SOAPEnvelope createSOAPEnvelope(OMXMLParserWrapper builder) {
+ return new SOAPEnvelopeImpl(builder, this);
+ }
+
+ public SOAPEnvelope createSOAPEnvelope() {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent,
+ OMXMLParserWrapper builder) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+
+ }
+
+
+ public SOAPFault createSOAPFault(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent) throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ throw new UnsupportedOperationException();
+ }
+
+
+ /**
+ * Method getDefaultEnvelope
+ *
+ * @return Returns SOAPEnvelope.
+ */
+ public SOAPEnvelope getDefaultEnvelope() throws SOAPProcessingException {
+ throw new UnsupportedOperationException();
+ }
+
+ public SOAPEnvelope getDefaultFaultEnvelope() throws SOAPProcessingException {
+ SOAPEnvelope defaultEnvelope = getDefaultEnvelope();
+ SOAPFault fault = createSOAPFault(defaultEnvelope.getBody());
+
+ SOAPFaultCode faultCode = createSOAPFaultCode(fault);
+ SOAPFaultValue value = createSOAPFaultValue(faultCode);
+
+ SOAPFaultReason reason = createSOAPFaultReason(fault);
+ SOAPFaultText faultText = createSOAPFaultText(reason);
+
+ SOAPFaultNode faultNode = createSOAPFaultNode(fault);
+ SOAPFaultRole faultRole = createSOAPFaultRole(fault);
+ SOAPFaultDetail faultDetail = createSOAPFaultDetail(fault);
+
+ return defaultEnvelope;
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11BodyImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11BodyImpl.java
new file mode 100644
index 0000000..bfa4db7
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11BodyImpl.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPBodyImpl;
+
+public class SOAP11BodyImpl extends SOAPBodyImpl {
+ /**
+ * @param envelope
+ */
+ public SOAP11BodyImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope);
+ }
+
+ /**
+ * Constructor SOAPBodyImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAP11BodyImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, builder);
+ }
+
+ public SOAPFault addFault(Exception e) throws OMException {
+ return new SOAP11Factory().createSOAPFault(this, e);
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11Factory.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11Factory.java
new file mode 100644
index 0000000..64850aa
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11Factory.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPEnvelopeImpl;
+import org.apache.ws.commons.soap.impl.llom.factory.SOAPLinkedListImplFactory;
+
+public class SOAP11Factory extends SOAPLinkedListImplFactory {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public String getSoapVersionURI() {
+ return SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI;
+ }
+
+ public SOAPEnvelope createSOAPEnvelope() {
+ return new SOAPEnvelopeImpl(
+ new OMNamespaceImpl(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP11Constants.SOAP_DEFAULT_NAMESPACE_PREFIX),
+ this);
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope) throws SOAPProcessingException {
+ return new SOAP11HeaderImpl(envelope);
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ return new SOAP11HeaderImpl(envelope, builder);
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ return new SOAP11HeaderBlockImpl(localName, ns, parent);
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent,
+ OMXMLParserWrapper builder) throws SOAPProcessingException {
+ return new SOAP11HeaderBlockImpl(localName, ns, parent, builder);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ return new SOAP11FaultImpl(parent, e);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent) throws SOAPProcessingException {
+ return new SOAP11FaultImpl(parent);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultImpl(parent, builder);
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope) throws SOAPProcessingException {
+ return new SOAP11BodyImpl(envelope);
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ return new SOAP11BodyImpl(envelope, builder);
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP11FaultCodeImpl(parent);
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent) throws SOAPProcessingException {
+ return new SOAP11FaultValueImpl(parent);
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultValueImpl(parent, builder);
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ return new SOAP11FaultValueImpl(parent);
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultValueImpl(parent, builder);
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent) throws SOAPProcessingException {
+ return new SOAP11FaultSubCodeImpl(parent);
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultSubCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ return new SOAP11FaultSubCodeImpl(parent);
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultSubCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP11FaultReasonImpl(parent);
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultReasonImpl(parent, builder);
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent) throws SOAPProcessingException {
+ return new SOAP11FaultTextImpl(parent);
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultTextImpl(parent, builder);
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP11FaultNodeImpl(parent);
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultNodeImpl(parent, builder);
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP11FaultRoleImpl(parent);
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultRoleImpl(parent, builder);
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP11FaultDetailImpl(parent);
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP11FaultDetailImpl(parent, builder);
+ }
+
+ public SOAPEnvelope getDefaultEnvelope() throws SOAPProcessingException {
+ OMNamespace ns =
+ new OMNamespaceImpl(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP11Constants.SOAP_DEFAULT_NAMESPACE_PREFIX);
+ SOAPEnvelopeImpl env = new SOAPEnvelopeImpl(ns, this);
+ createSOAPHeader(env);
+ createSOAPBody(env);
+ return env;
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultCodeImpl.java
new file mode 100644
index 0000000..d26572a
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultCodeImpl.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultCodeImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class SOAP11FaultCodeImpl extends SOAPFaultCodeImpl {
+ /**
+ * Constructor OMElementImpl
+ *
+ * @param parent
+ * @param builder
+ */
+ public SOAP11FaultCodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAP11FaultCodeImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, false);
+ }
+
+
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException {
+ if (!(subCode instanceof SOAP11FaultSubCodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Sub Code. But received some other implementation");
+ }
+ super.setSubCode(subCode);
+ }
+
+ public void setValue(SOAPFaultValue value) throws SOAPProcessingException {
+ if (!(value instanceof SOAP11FaultValueImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Value. But received some other implementation");
+ }
+ super.setValue(value);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(
+ new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.getNamespace() != null) {
+ String prefix = this.getNamespace().getPrefix();
+ String nameSpaceName = this.getNamespace().getName();
+ writer.writeStartElement(prefix, SOAP11Constants.SOAP_FAULT_CODE_LOCAL_NAME,
+ nameSpaceName);
+ } else {
+ writer.writeStartElement(
+ SOAP11Constants.SOAP_FAULT_CODE_LOCAL_NAME);
+ }
+
+ OMSerializerUtil.serializeAttributes(this, omOutput);
+ OMSerializerUtil.serializeNamespaces(this, omOutput);
+
+
+ String text = this.getValue().getText();
+ writer.writeCharacters(text);
+ writer.writeEndElement();
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultDetailImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultDetailImpl.java
new file mode 100644
index 0000000..a59c728
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultDetailImpl.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultDetailImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class SOAP11FaultDetailImpl extends SOAPFaultDetailImpl {
+ public SOAP11FaultDetailImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, false);
+ }
+
+ public SOAP11FaultDetailImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+
+ public void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(
+ new StreamWriterToContentHandlerConverter(omOutput));
+ }
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.getNamespace() != null) {
+ String prefix = this.getNamespace().getPrefix();
+ String nameSpaceName = this.getNamespace().getName();
+ writer.writeStartElement(prefix, SOAP11Constants.SOAP_FAULT_DETAIL_LOCAL_NAME,
+ nameSpaceName);
+ } else {
+ writer.writeStartElement(
+ SOAP11Constants.SOAP_FAULT_DETAIL_LOCAL_NAME);
+ }
+ OMSerializerUtil.serializeAttributes(this, omOutput);
+ OMSerializerUtil.serializeNamespaces(this, omOutput);
+
+
+ String text = this.getText();
+ writer.writeCharacters(text);
+
+
+ if (firstChild != null) {
+ ((OMNodeEx)firstChild).serializeAndConsume(omOutput);
+ }
+ writer.writeEndElement();
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultImpl.java
new file mode 100644
index 0000000..6011736
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultImpl.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultImpl;
+
+import javax.xml.stream.XMLStreamException;
+
+
+public class SOAP11FaultImpl extends SOAPFaultImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public SOAP11FaultImpl(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ super(parent, e);
+ }
+
+ public SOAP11FaultImpl(SOAPBody parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * This is a convenience method for the SOAP Fault Impl.
+ *
+ * @param parent
+ */
+ public SOAP11FaultImpl(SOAPBody parent) throws SOAPProcessingException {
+ super(parent);
+
+ }
+
+ protected SOAPFaultDetail getNewSOAPFaultDetail(SOAPFault fault) throws SOAPProcessingException {
+ return new SOAP11FaultDetailImpl(fault);
+ }
+
+ public void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ super.serialize(omOutput);
+ }
+
+ public void serializeAndConsume(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ super.serializeAndConsume(omOutput);
+ }
+
+ public void setCode(SOAPFaultCode soapFaultCode) throws SOAPProcessingException {
+ if (!(soapFaultCode instanceof SOAP11FaultCodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Code. But received some other implementation");
+ }
+ super.setCode(soapFaultCode);
+ }
+
+ public void setReason(SOAPFaultReason reason) throws SOAPProcessingException {
+ if (!(reason instanceof SOAP11FaultReasonImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Reason. But received some other implementation");
+ }
+ super.setReason(reason);
+ }
+
+ public void setNode(SOAPFaultNode node) throws SOAPProcessingException {
+ if (!(node instanceof SOAP11FaultNodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Node. But received some other implementation");
+ }
+ super.setNode(node);
+ }
+
+ public void setRole(SOAPFaultRole role) throws SOAPProcessingException {
+ if (!(role instanceof SOAP11FaultRoleImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Role. But received some other implementation");
+ }
+ super.setRole(role);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11BodyImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Body as the parent. But received some other implementation");
+ }
+ }
+
+ public void setDetail(SOAPFaultDetail detail) throws SOAPProcessingException {
+ if (!(detail instanceof SOAP11FaultDetailImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Detail. But received some other implementation");
+ }
+ super.setDetail(detail);
+ }
+
+ protected void serializeFaultNode(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultNodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultNodeImpl.java
new file mode 100644
index 0000000..2d01dc6
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultNodeImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultNodeImpl;
+
+
+public class SOAP11FaultNodeImpl extends SOAPFaultNodeImpl {
+
+ public SOAP11FaultNodeImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP11FaultNodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultReasonImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultReasonImpl.java
new file mode 100644
index 0000000..06beef6
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultReasonImpl.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMOutputImpl;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultReasonImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class SOAP11FaultReasonImpl extends SOAPFaultReasonImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public SOAP11FaultReasonImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAP11FaultReasonImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, false);
+ }
+
+ public void setSOAPText(SOAPFaultText soapFaultText) throws SOAPProcessingException {
+ if (!(soapFaultText instanceof SOAP11FaultTextImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault Text. But received some other implementation");
+ }
+ super.setSOAPText(soapFaultText);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+
+ protected void serialize(OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(
+ new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.getNamespace() != null) {
+ String prefix = this.getNamespace().getPrefix();
+ String nameSpaceName = this.getNamespace().getName();
+ writer.writeStartElement(prefix, SOAP11Constants.SOAP_FAULT_STRING_LOCAL_NAME,
+ nameSpaceName);
+ } else {
+ writer.writeStartElement(
+ SOAP11Constants.SOAP_FAULT_STRING_LOCAL_NAME);
+ }
+ OMSerializerUtil.serializeAttributes(this, omOutput);
+ OMSerializerUtil.serializeNamespaces(this, omOutput);
+
+ String text = this.getSOAPText().getText();
+ writer.writeCharacters(text);
+ writer.writeEndElement();
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultRoleImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultRoleImpl.java
new file mode 100644
index 0000000..e987305
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultRoleImpl.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMSerializerUtil;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamWriterToContentHandlerConverter;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultRoleImpl;
+
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+public class SOAP11FaultRoleImpl extends SOAPFaultRoleImpl {
+ public SOAP11FaultRoleImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, false);
+ }
+
+ public SOAP11FaultRoleImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+
+ protected void serialize(org.apache.ws.commons.om.impl.OMOutputImpl omOutput, boolean cache) throws XMLStreamException {
+
+ // select the builder
+ short builderType = PULL_TYPE_BUILDER; // default is pull type
+ if (builder != null) {
+ builderType = this.builder.getBuilderType();
+ }
+ if ((builderType == PUSH_TYPE_BUILDER)
+ && (builder.getRegisteredContentHandler() == null)) {
+ builder.registerExternalContentHandler(
+ new StreamWriterToContentHandlerConverter(omOutput));
+ }
+
+ XMLStreamWriter writer = omOutput.getXmlStreamWriter();
+ if (this.getNamespace() != null) {
+ String prefix = this.getNamespace().getPrefix();
+ String nameSpaceName = this.getNamespace().getName();
+ writer.writeStartElement(prefix, SOAP11Constants.SOAP_FAULT_ACTOR_LOCAL_NAME,
+ nameSpaceName);
+ } else {
+ writer.writeStartElement(
+ SOAP11Constants.SOAP_FAULT_ACTOR_LOCAL_NAME);
+ }
+ OMSerializerUtil.serializeAttributes(this, omOutput);
+ OMSerializerUtil.serializeNamespaces(this, omOutput);
+
+ String text = this.getText();
+ writer.writeCharacters(text);
+ writer.writeEndElement();
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultSubCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultSubCodeImpl.java
new file mode 100644
index 0000000..1285e0d
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultSubCodeImpl.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultSubCodeImpl;
+
+public class SOAP11FaultSubCodeImpl extends SOAPFaultSubCodeImpl {
+ //changed
+ public SOAP11FaultSubCodeImpl(SOAPFaultCode parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+
+ //changed
+ public SOAP11FaultSubCodeImpl(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME, builder);
+ }
+
+ public SOAP11FaultSubCodeImpl(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+
+ public SOAP11FaultSubCodeImpl(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultSubCodeImpl) ||
+ (parent instanceof SOAP11FaultCodeImpl)) {
+ throw new SOAPProcessingException("Expecting SOAP 1.1 implementation of SOAP FaultSubCode or SOAP FaultCode as the parent. But received some other implementation");
+ }
+ }
+
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException {
+ if (!((parent instanceof SOAP11FaultSubCodeImpl) || (parent instanceof SOAP11FaultCodeImpl))) {
+ throw new SOAPProcessingException("Expecting SOAP 1.1 implementation of SOAP Fault Sub Code. But received some other implementation");
+ }
+ super.setSubCode(subCode);
+ }
+
+ public void setValue(SOAPFaultValue soapFaultSubCodeValue) throws SOAPProcessingException {
+ if (!(soapFaultSubCodeValue instanceof SOAP11FaultValueImpl)) {
+ throw new SOAPProcessingException("Expecting SOAP 1.1 implementation of SOAP Fault Value. But received some other implementation");
+ }
+ super.setValue(soapFaultSubCodeValue);
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultTextImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultTextImpl.java
new file mode 100644
index 0000000..f76efc8
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultTextImpl.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultTextImpl;
+
+public class SOAP11FaultTextImpl extends SOAPFaultTextImpl {
+ public SOAP11FaultTextImpl(SOAPFaultReason parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP11FaultTextImpl(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11FaultReasonImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP FaultReason as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultValueImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultValueImpl.java
new file mode 100644
index 0000000..96bf6fa
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11FaultValueImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultValueImpl;
+
+public class SOAP11FaultValueImpl extends SOAPFaultValueImpl {
+ public SOAP11FaultValueImpl(OMElement parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP11FaultValueImpl(OMElement parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!((parent instanceof SOAP11FaultSubCodeImpl) ||
+ (parent instanceof SOAP11FaultCodeImpl))) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP FaultSubCode or SOAP FaultCode as the parent. But received some other implementation." +
+ parent.getClass());
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderBlockImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderBlockImpl.java
new file mode 100644
index 0000000..572eff0
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderBlockImpl.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPHeaderBlockImpl;
+
+public class SOAP11HeaderBlockImpl extends SOAPHeaderBlockImpl {
+ /**
+ * @param localName
+ * @param ns
+ */
+ public SOAP11HeaderBlockImpl(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ super(localName, ns, parent);
+ checkParent(parent);
+ }
+
+ /**
+ * Constructor SOAPHeaderBlockImpl
+ *
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ */
+ public SOAP11HeaderBlockImpl(String localName,
+ OMNamespace ns,
+ OMElement parent,
+ OMXMLParserWrapper builder) {
+ super(localName, ns, parent, builder);
+ }
+
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP11HeaderImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.1 implementation of SOAP Body as the parent. But received some other implementation");
+ }
+ }
+
+ public void setRole(String roleURI) {
+ setAttribute(SOAP11Constants.ATTR_ACTOR,
+ roleURI,
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+
+ }
+
+ public String getRole() {
+ return getAttribute(SOAP11Constants.ATTR_ACTOR,
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ }
+
+ public void setMustUnderstand(boolean mustUnderstand) {
+ setAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ mustUnderstand ? "1" : "0",
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ }
+
+ public void setMustUnderstand(String mustUnderstand) throws SOAPProcessingException {
+ if (SOAPConstants.ATTR_MUSTUNDERSTAND_TRUE.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_FALSE.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_0.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_1.equals(mustUnderstand)) {
+ setAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ mustUnderstand,
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ } else {
+ throw new SOAPProcessingException(
+ "mustUndertand should be one of \"true\", \"false\", \"0\" or \"1\" ");
+ }
+ }
+
+ /**
+ * Returns whether the mustUnderstand attribute for this
+ * <CODE>SOAPHeaderBlock</CODE> object is turned on.
+ *
+ * @return <CODE>true</CODE> if the mustUnderstand attribute of
+ * this <CODE>SOAPHeaderBlock</CODE> object is turned on;
+ * <CODE>false</CODE> otherwise
+ */
+ public boolean getMustUnderstand() throws SOAPProcessingException {
+ String mustUnderstand = "";
+ if ((mustUnderstand =
+ getAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI))
+ != null) {
+ if (SOAPConstants.ATTR_MUSTUNDERSTAND_TRUE.equalsIgnoreCase(
+ mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_1.equalsIgnoreCase(
+ mustUnderstand)) {
+ return true;
+ } else if (SOAPConstants.ATTR_MUSTUNDERSTAND_FALSE.equalsIgnoreCase(
+ mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_0.equalsIgnoreCase(
+ mustUnderstand)) {
+ return false;
+ } else {
+ throw new SOAPProcessingException(
+ "Invalid value found in mustUnderstand value of " +
+ this.getLocalName() +
+ " header block");
+ }
+ }
+ return false;
+
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderImpl.java
new file mode 100644
index 0000000..dcf03bb
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11HeaderImpl.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenWithSpecificAttributeIterator;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPHeaderImpl;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+public class SOAP11HeaderImpl extends SOAPHeaderImpl {
+ /**
+ * @param envelope
+ */
+ public SOAP11HeaderImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope);
+ }
+
+ /**
+ * Constructor SOAPHeaderImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAP11HeaderImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, builder);
+ }
+
+ public SOAPHeaderBlock addHeaderBlock(String localName, OMNamespace ns) throws OMException {
+ if (ns == null || ns.getName() == null || "".equals(ns.getName())) {
+ throw new OMException(
+ "All the SOAP Header blocks should be namespace qualified");
+ }
+
+ OMNamespace namespace = findNamespace(ns.getName(), ns.getPrefix());
+ if (namespace != null) {
+ ns = namespace;
+ }
+
+ SOAPHeaderBlock soapHeaderBlock = null;
+ try {
+ soapHeaderBlock = new SOAP11HeaderBlockImpl(localName, ns, this);
+ } catch (SOAPProcessingException e) {
+ throw new OMException(e);
+ }
+ ((OMNodeEx)soapHeaderBlock).setComplete(true);
+ return soapHeaderBlock;
+ }
+
+ public Iterator extractHeaderBlocks(String role) {
+ return new OMChildrenWithSpecificAttributeIterator(getFirstOMChild(),
+ new QName(SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP11Constants.ATTR_ACTOR),
+ role,
+ true);
+
+ }
+
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12BodyImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12BodyImpl.java
new file mode 100644
index 0000000..0b3cbba
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12BodyImpl.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPBodyImpl;
+
+public class SOAP12BodyImpl extends SOAPBodyImpl {
+ /**
+ * @param envelope
+ */
+ public SOAP12BodyImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope);
+ }
+
+ /**
+ * Constructor SOAPBodyImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAP12BodyImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, builder);
+ }
+
+ public SOAPFault addFault(Exception e) throws OMException {
+ SOAPFault soapFault = new SOAP12FaultImpl(this, e);
+ return soapFault;
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12Factory.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12Factory.java
new file mode 100644
index 0000000..2ebaffc
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12Factory.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPEnvelopeImpl;
+import org.apache.ws.commons.soap.impl.llom.factory.SOAPLinkedListImplFactory;
+
+public class SOAP12Factory extends SOAPLinkedListImplFactory {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public String getSoapVersionURI() {
+ return SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI;
+ }
+
+ public SOAPEnvelope createSOAPEnvelope() {
+ return new SOAPEnvelopeImpl(
+ new OMNamespaceImpl(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP12Constants.SOAP_DEFAULT_NAMESPACE_PREFIX),
+ this);
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope) throws SOAPProcessingException {
+ return new SOAP12HeaderImpl(envelope);
+ }
+
+ public SOAPHeader createSOAPHeader(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ return new SOAP12HeaderImpl(envelope, builder);
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ return new SOAP12HeaderBlockImpl(localName, ns, parent);
+ }
+
+ public SOAPHeaderBlock createSOAPHeaderBlock(String localName,
+ OMNamespace ns,
+ SOAPHeader parent,
+ OMXMLParserWrapper builder) throws SOAPProcessingException {
+ return new SOAP12HeaderBlockImpl(localName, ns, parent, builder);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ return new SOAP12FaultImpl(parent, e);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent) throws SOAPProcessingException {
+ return new SOAP12FaultImpl(parent);
+ }
+
+ public SOAPFault createSOAPFault(SOAPBody parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultImpl(parent, builder);
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope) throws SOAPProcessingException {
+ return new SOAP12BodyImpl(envelope);
+ }
+
+ public SOAPBody createSOAPBody(SOAPEnvelope envelope,
+ OMXMLParserWrapper builder) {
+ return new SOAP12BodyImpl(envelope, builder);
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP12FaultCodeImpl(parent);
+ }
+
+ public SOAPFaultCode createSOAPFaultCode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent) throws SOAPProcessingException {
+ return new SOAP12FaultValueImpl(parent);
+ }
+
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultValueImpl(parent, builder);
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ return new SOAP12FaultValueImpl(parent);
+ }
+
+ //added
+ public SOAPFaultValue createSOAPFaultValue(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultValueImpl(parent, builder);
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent) throws SOAPProcessingException {
+ return new SOAP12FaultSubCodeImpl(parent);
+ }
+
+ //changed
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultSubCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ return new SOAP12FaultSubCodeImpl(parent);
+ }
+
+ public SOAPFaultSubCode createSOAPFaultSubCode(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultSubCodeImpl(parent, builder);
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP12FaultReasonImpl(parent);
+ }
+
+ public SOAPFaultReason createSOAPFaultReason(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultReasonImpl(parent, builder);
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent) throws SOAPProcessingException {
+ return new SOAP12FaultTextImpl(parent);
+ }
+
+ public SOAPFaultText createSOAPFaultText(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultTextImpl(parent, builder);
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP12FaultNodeImpl(parent);
+ }
+
+ public SOAPFaultNode createSOAPFaultNode(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultNodeImpl(parent, builder);
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP12FaultRoleImpl(parent);
+ }
+
+ public SOAPFaultRole createSOAPFaultRole(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultRoleImpl(parent, builder);
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent) throws SOAPProcessingException {
+ return new SOAP12FaultDetailImpl(parent);
+ }
+
+ public SOAPFaultDetail createSOAPFaultDetail(SOAPFault parent,
+ OMXMLParserWrapper builder) {
+ return new SOAP12FaultDetailImpl(parent, builder);
+ }
+
+ public SOAPEnvelope getDefaultEnvelope() throws SOAPProcessingException {
+ OMNamespace ns =
+ new OMNamespaceImpl(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP12Constants.SOAP_DEFAULT_NAMESPACE_PREFIX);
+ SOAPEnvelopeImpl env = new SOAPEnvelopeImpl(ns, this);
+ createSOAPHeader(env);
+ createSOAPBody(env);
+
+ return env;
+ }
+
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultCodeImpl.java
new file mode 100644
index 0000000..a150291
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultCodeImpl.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultCodeImpl;
+
+public class SOAP12FaultCodeImpl extends SOAPFaultCodeImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ /**
+ * Constructor OMElementImpl
+ *
+ * @param parent
+ * @param builder
+ */
+ public SOAP12FaultCodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAP12FaultCodeImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, true);
+ }
+
+
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException {
+ if (!(subCode instanceof SOAP12FaultSubCodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Sub Code. But received some other implementation");
+ }
+ super.setSubCode(subCode);
+ }
+
+ public void setValue(SOAPFaultValue value) throws SOAPProcessingException {
+ if (!(value instanceof SOAP12FaultValueImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Value. But received some other implementation");
+ }
+ super.setValue(value);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultDetailImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultDetailImpl.java
new file mode 100644
index 0000000..d3a8576
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultDetailImpl.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultDetailImpl;
+
+
+public class SOAP12FaultDetailImpl extends SOAPFaultDetailImpl {
+ public SOAP12FaultDetailImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, true);
+ }
+
+ public SOAP12FaultDetailImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultImpl.java
new file mode 100644
index 0000000..f1fe461
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultImpl.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultImpl;
+
+import javax.xml.stream.XMLStreamException;
+
+
+public class SOAP12FaultImpl extends SOAPFaultImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ public SOAP12FaultImpl(SOAPBody parent, Exception e) throws SOAPProcessingException {
+ super(parent, e);
+ }
+
+ public SOAP12FaultImpl(SOAPBody parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * This is a convenience method for the SOAP Fault Impl.
+ *
+ * @param parent
+ */
+ public SOAP12FaultImpl(SOAPBody parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ protected SOAPFaultDetail getNewSOAPFaultDetail(SOAPFault fault) {
+ return new SOAP12FaultDetailImpl(fault);
+
+ }
+
+ public void setCode(SOAPFaultCode soapFaultCode) throws SOAPProcessingException {
+ if (!(soapFaultCode instanceof SOAP12FaultCodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Code. But received some other implementation");
+ }
+ super.setCode(soapFaultCode);
+ }
+
+
+ public void setReason(SOAPFaultReason reason) throws SOAPProcessingException {
+ if (!(reason instanceof SOAP12FaultReasonImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Reason. But received some other implementation");
+ }
+ super.setReason(reason);
+ }
+
+ public void setNode(SOAPFaultNode node) throws SOAPProcessingException {
+ if (!(node instanceof SOAP12FaultNodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Node. But received some other implementation");
+ }
+ super.setNode(node);
+ }
+
+ public void setRole(SOAPFaultRole role) throws SOAPProcessingException {
+ if (!(role instanceof SOAP12FaultRoleImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Role. But received some other implementation");
+ }
+ super.setRole(role);
+ }
+
+ public void setDetail(SOAPFaultDetail detail) throws SOAPProcessingException {
+ if (!(detail instanceof SOAP12FaultDetailImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Detail. But received some other implementation");
+ }
+ super.setDetail(detail);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12BodyImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Body as the parent. But received some other implementation");
+ }
+ }
+
+ protected void serializeFaultNode(org.apache.ws.commons.om.impl.OMOutputImpl omOutput) throws XMLStreamException {
+ SOAPFaultNode faultNode = getNode();
+ if (faultNode != null) {
+ ((OMNodeEx)faultNode).serialize(omOutput);
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultNodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultNodeImpl.java
new file mode 100644
index 0000000..180c250
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultNodeImpl.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultNodeImpl;
+
+
+public class SOAP12FaultNodeImpl extends SOAPFaultNodeImpl {
+ public SOAP12FaultNodeImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP12FaultNodeImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultReasonImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultReasonImpl.java
new file mode 100644
index 0000000..0304a27
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultReasonImpl.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultReasonImpl;
+
+public class SOAP12FaultReasonImpl extends SOAPFaultReasonImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ public SOAP12FaultReasonImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ /**
+ * @param parent
+ */
+ public SOAP12FaultReasonImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, true);
+ }
+
+ public void setSOAPText(SOAPFaultText soapFaultText) throws SOAPProcessingException {
+ if (!(soapFaultText instanceof SOAP12FaultTextImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Text. But received some other implementation");
+ }
+ super.setSOAPText(soapFaultText);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultRoleImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultRoleImpl.java
new file mode 100644
index 0000000..31b799b
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultRoleImpl.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultRoleImpl;
+
+public class SOAP12FaultRoleImpl extends SOAPFaultRoleImpl {
+ public SOAP12FaultRoleImpl(SOAPFault parent) throws SOAPProcessingException {
+ super(parent, true);
+ }
+
+ public SOAP12FaultRoleImpl(SOAPFault parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultSubCodeImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultSubCodeImpl.java
new file mode 100644
index 0000000..69184d8
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultSubCodeImpl.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultSubCodeImpl;
+
+public class SOAP12FaultSubCodeImpl extends SOAPFaultSubCodeImpl {
+ //changed
+ public SOAP12FaultSubCodeImpl(SOAPFaultCode parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+
+ //changed
+ public SOAP12FaultSubCodeImpl(SOAPFaultCode parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME, builder);
+ }
+
+ public SOAP12FaultSubCodeImpl(SOAPFaultSubCode parent) throws SOAPProcessingException {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME);
+ }
+
+ public SOAP12FaultSubCodeImpl(SOAPFaultSubCode parent,
+ OMXMLParserWrapper builder) {
+ super(parent, SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!((parent instanceof SOAP12FaultSubCodeImpl) ||
+ (parent instanceof SOAP12FaultCodeImpl))) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP FaultSubCode or SOAP FaultCodeValue as the parent. But received some other implementation");
+ }
+ }
+
+ public void setSubCode(SOAPFaultSubCode subCode) throws SOAPProcessingException {
+ if (!(subCode instanceof SOAP12FaultSubCodeImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Sub Code. But received some other implementation");
+ }
+ super.setSubCode(subCode);
+ }
+
+ public void setValue(SOAPFaultValue soapFaultSubCodeValue) throws SOAPProcessingException {
+ if (!(soapFaultSubCodeValue instanceof SOAP12FaultValueImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Fault Value. But received some other implementation");
+ }
+ super.setValue(soapFaultSubCodeValue);
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultTextImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultTextImpl.java
new file mode 100644
index 0000000..e235165
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultTextImpl.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultTextImpl;
+
+public class SOAP12FaultTextImpl extends SOAPFaultTextImpl {
+ public SOAP12FaultTextImpl(SOAPFaultReason parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP12FaultTextImpl(SOAPFaultReason parent,
+ OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12FaultReasonImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP FaultReason as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultValueImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultValueImpl.java
new file mode 100644
index 0000000..ed042ba
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12FaultValueImpl.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPFaultValueImpl;
+
+
+public class SOAP12FaultValueImpl extends SOAPFaultValueImpl {
+ public SOAP12FaultValueImpl(OMElement parent) throws SOAPProcessingException {
+ super(parent);
+ }
+
+ public SOAP12FaultValueImpl(OMElement parent, OMXMLParserWrapper builder) {
+ super(parent, builder);
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!((parent instanceof SOAP12FaultSubCodeImpl) ||
+ (parent instanceof SOAP12FaultCodeImpl))) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP FaultSubCode or SOAP FaultCode as the parent. But received some other implementation");
+ }
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderBlockImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderBlockImpl.java
new file mode 100644
index 0000000..4cd3502
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderBlockImpl.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPHeaderBlockImpl;
+
+public class SOAP12HeaderBlockImpl extends SOAPHeaderBlockImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+ /**
+ * @param localName
+ * @param ns
+ */
+ public SOAP12HeaderBlockImpl(String localName,
+ OMNamespace ns,
+ SOAPHeader parent) throws SOAPProcessingException {
+ super(localName, ns, parent);
+ checkParent(parent);
+ }
+
+ /**
+ * Constructor SOAPHeaderBlockImpl
+ *
+ * @param localName
+ * @param ns
+ * @param parent
+ * @param builder
+ */
+ public SOAP12HeaderBlockImpl(String localName,
+ OMNamespace ns,
+ SOAPHeader parent,
+ OMXMLParserWrapper builder) {
+ super(localName, ns, parent, builder);
+
+ }
+
+ protected void checkParent(OMElement parent) throws SOAPProcessingException {
+ if (!(parent instanceof SOAP12HeaderImpl)) {
+ throw new SOAPProcessingException(
+ "Expecting SOAP 1.2 implementation of SOAP Body as the parent. But received some other implementation");
+ }
+ }
+
+ public void setRole(String roleURI) {
+ setAttribute(SOAP12Constants.SOAP_ROLE,
+ roleURI,
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ }
+
+ public String getRole() {
+ return getAttribute(SOAP12Constants.SOAP_ROLE,
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+
+ }
+
+ public void setMustUnderstand(boolean mustUnderstand) {
+ setAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ mustUnderstand ? "1" : "0",
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+
+ }
+
+ public void setMustUnderstand(String mustUnderstand) throws SOAPProcessingException {
+ if (SOAPConstants.ATTR_MUSTUNDERSTAND_TRUE.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_FALSE.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_0.equals(mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_1.equals(mustUnderstand)) {
+ setAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ mustUnderstand,
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ } else {
+ throw new SOAPProcessingException(
+ "mustUndertand should be one of \"true\", \"false\", \"0\" or \"1\" ");
+ }
+ }
+
+ public boolean getMustUnderstand() throws SOAPProcessingException {
+ String mustUnderstand = "";
+ if ((mustUnderstand =
+ getAttribute(SOAPConstants.ATTR_MUSTUNDERSTAND,
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI))
+ != null) {
+ if (SOAPConstants.ATTR_MUSTUNDERSTAND_TRUE.equalsIgnoreCase(
+ mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_1.equalsIgnoreCase(
+ mustUnderstand)) {
+ return true;
+ } else if (SOAPConstants.ATTR_MUSTUNDERSTAND_FALSE.equalsIgnoreCase(
+ mustUnderstand) ||
+ SOAPConstants.ATTR_MUSTUNDERSTAND_0.equalsIgnoreCase(
+ mustUnderstand)) {
+ return false;
+ } else {
+ throw new SOAPProcessingException(
+ "Invalid value found in mustUnderstand value of " +
+ this.getLocalName() +
+ " header block");
+ }
+ }
+ return false;
+
+ }
+}
diff --git a/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderImpl.java b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderImpl.java
new file mode 100644
index 0000000..0f6be40
--- /dev/null
+++ b/src/org/apache/ws/commons/soap/impl/llom/soap12/SOAP12HeaderImpl.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap12;
+
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.OMNodeEx;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenWithSpecificAttributeIterator;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.ws.commons.soap.impl.llom.SOAPHeaderImpl;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+public class SOAP12HeaderImpl extends SOAPHeaderImpl {
+ /**
+ * Eran Chinthaka (chinthaka@apache.org)
+ */
+
+ /**
+ * @param envelope
+ */
+ public SOAP12HeaderImpl(SOAPEnvelope envelope) throws SOAPProcessingException {
+ super(envelope);
+ }
+
+ /**
+ * Constructor SOAPHeaderImpl
+ *
+ * @param envelope
+ * @param builder
+ */
+ public SOAP12HeaderImpl(SOAPEnvelope envelope, OMXMLParserWrapper builder) {
+ super(envelope, builder);
+ }
+
+ public SOAPHeaderBlock addHeaderBlock(String localName, OMNamespace ns) throws OMException {
+ if (ns == null || ns.getName() == null || "".equals(ns.getName())) {
+ throw new OMException(
+ "All the SOAP Header blocks should be namespace qualified");
+ }
+
+ OMNamespace namespace = findNamespace(ns.getName(), ns.getPrefix());
+ if (namespace != null) {
+ ns = namespace;
+ }
+
+ SOAPHeaderBlock soapHeaderBlock = null;
+ try {
+ soapHeaderBlock = new SOAP12HeaderBlockImpl(localName, ns, this);
+ } catch (SOAPProcessingException e) {
+ throw new OMException(e);
+ }
+ ((OMNodeEx)soapHeaderBlock).setComplete(true);
+ return soapHeaderBlock;
+ }
+
+
+ public Iterator extractHeaderBlocks(String role) {
+ return new OMChildrenWithSpecificAttributeIterator(getFirstOMChild(),
+ new QName(SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAP12Constants.SOAP_ROLE),
+ role,
+ true);
+ }
+
+}
diff --git a/test/org/apache/ws/commons/attachments/Base64Test.java b/test/org/apache/ws/commons/attachments/Base64Test.java
new file mode 100644
index 0000000..b44acf4
--- /dev/null
+++ b/test/org/apache/ws/commons/attachments/Base64Test.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import junit.framework.TestCase;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import org.apache.ws.commons.om.util.Base64;
+
+public class Base64Test extends TestCase {
+
+ Object expectedObject;
+
+ ByteArrayInputStream byteStream;
+
+ /*
+ * Class under test for String encode(byte[])
+ */
+
+ public void testEncodebyteArray() throws Exception {
+ Object actualObject;
+ String expectedBase64;
+ expectedObject = new String("Lanka Software Foundation");
+ ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
+ ObjectOutputStream objectOutStream = new ObjectOutputStream(byteStream);
+ objectOutStream.writeObject(expectedObject);
+ expectedBase64 = Base64.encode(byteStream.toByteArray());
+ byte[] tempa = Base64.decode(expectedBase64);
+ ObjectInputStream objectInStream = new ObjectInputStream(
+ new ByteArrayInputStream(tempa));
+ actualObject = objectInStream.readObject();
+ assertEquals("Base64 Encoding Check", expectedObject, actualObject);
+ }
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/attachments/ImageSampleTest.java b/test/org/apache/ws/commons/attachments/ImageSampleTest.java
new file mode 100644
index 0000000..2c6adaa
--- /dev/null
+++ b/test/org/apache/ws/commons/attachments/ImageSampleTest.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import org.apache.ws.commons.attachments.utils.ImageDataSource;
+import org.apache.ws.commons.attachments.utils.ImageIO;
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMOutputFormat;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.llom.OMElementImpl;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.om.impl.llom.OMTextImpl;
+import org.apache.ws.commons.om.impl.llom.mtom.MTOMStAXSOAPModelBuilder;
+
+import javax.activation.DataHandler;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.awt.*;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class ImageSampleTest extends AbstractTestCase {
+
+ public ImageSampleTest(String testName) {
+ super(testName);
+ }
+
+ /*
+ * @see TestCase#setUp()
+ */
+ Image expectedImage;
+
+ MTOMStAXSOAPModelBuilder builder;
+
+ DataHandler expectedDH;
+
+ File outMTOMFile;
+
+ File outBase64File;
+
+ String outFileName = "target/ActualImageMTOMOut.bin";
+
+ String outBase64FileName = "target/OMSerializeBase64Out.xml";
+
+ String imageInFileName = "mtom/img/test.jpg";
+
+ String imageOutFileName = "target/testOut.jpg";
+
+ String inMimeFileName = "mtom/ImageMTOMOut.bin";
+
+ String contentTypeString = "multipart/Related; type=\"application/xop+xml\";start=\"<SOAPPart>\"; boundary=\"----=_AxIs2_Def_boundary_=42214532\"";
+
+
+
+ public void testImageSampleSerialize() throws Exception {
+
+ outMTOMFile = new File(outFileName);
+ outBase64File = new File(outBase64FileName);
+ OMOutputFormat mtomOutputFormat = new OMOutputFormat();
+ mtomOutputFormat.setDoOptimize(true);
+ OMOutputFormat baseOutputFormat = new OMOutputFormat();
+ baseOutputFormat.setDoOptimize(false);
+
+ OMNamespaceImpl soap = new OMNamespaceImpl(
+ "http://schemas.xmlsoap.org/soap/envelope/", "soap");
+ OMElement envelope = new OMElementImpl("Envelope", soap);
+ OMElement body = new OMElementImpl("Body", soap);
+
+ OMNamespaceImpl dataName = new OMNamespaceImpl(
+ "http://www.example.org/stuff", "m");
+ OMElement data = new OMElementImpl("data", dataName);
+
+ expectedImage =
+ new ImageIO().loadImage(
+ new FileInputStream(
+ getTestResourceFile(imageInFileName)));
+ ImageDataSource dataSource = new ImageDataSource("WaterLilies.jpg",
+ expectedImage);
+ expectedDH = new DataHandler(dataSource);
+ OMText binaryNode = new OMTextImpl(expectedDH, true);
+
+ envelope.addChild(body);
+ body.addChild(data);
+ data.addChild(binaryNode);
+
+ envelope.serializeAndConsume(new FileOutputStream(outBase64File), baseOutputFormat);
+ envelope.serializeAndConsume(new FileOutputStream(outMTOMFile), mtomOutputFormat);
+ }
+
+ public void testImageSampleDeserialize() throws Exception {
+ InputStream inStream = new FileInputStream(
+ getTestResourceFile(inMimeFileName));
+ MIMEHelper mimeHelper = new MIMEHelper(inStream, contentTypeString);
+ XMLStreamReader reader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(
+ new BufferedReader(
+ new InputStreamReader(
+ mimeHelper
+ .getSOAPPartInputStream())));
+ builder = new MTOMStAXSOAPModelBuilder(reader, mimeHelper, null);
+ OMElement root = builder.getDocumentElement();
+ OMElement body = (OMElement) root.getFirstOMChild();
+ OMElement data = (OMElement) body.getFirstOMChild();
+ OMText blob = (OMText) data.getFirstOMChild();
+ /*
+ * Following is the procedure the user has to follow to read objects in
+ * OBBlob User has to know the object type & whether it is serializable.
+ * If it is not he has to use a Custom Defined DataSource to get the
+ * Object.
+ */
+
+ DataHandler actualDH;
+ actualDH = (DataHandler)blob.getDataHandler();
+ Image actualObject = new ImageIO().loadImage(actualDH.getDataSource()
+ .getInputStream());
+ FileOutputStream imageOutStream = new FileOutputStream(
+ new File(imageOutFileName));
+ new ImageIO().saveImage("image/jpeg", actualObject, imageOutStream);
+
+ }
+
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/attachments/MIMEHelperTest.java b/test/org/apache/ws/commons/attachments/MIMEHelperTest.java
new file mode 100644
index 0000000..fde7e94
--- /dev/null
+++ b/test/org/apache/ws/commons/attachments/MIMEHelperTest.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.attachments;
+
+import junit.framework.TestCase;
+
+public class MIMEHelperTest extends TestCase {
+
+
+ public void testMIMEHelper() {
+ }
+
+ public void testGetAttachmentSpecType() {
+ }
+
+ public void testGetSOAPPartInputStream() {
+ }
+
+ public void testGetDataHandler() {
+ }
+
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/om/AbstractOMSerializationTest.java b/test/org/apache/ws/commons/om/AbstractOMSerializationTest.java
new file mode 100644
index 0000000..32d7d07
--- /dev/null
+++ b/test/org/apache/ws/commons/om/AbstractOMSerializationTest.java
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.custommonkey.xmlunit.Diff;
+import org.custommonkey.xmlunit.XMLTestCase;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.transform.Result;
+import javax.xml.transform.Source;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class AbstractOMSerializationTest extends XMLTestCase {
+
+ protected boolean ignoreXMLDeclaration = true;
+ protected boolean ignoreDocument = false;
+ protected Log log = LogFactory.getLog(getClass());
+
+
+ /**
+ * @param xmlString - remember this is not the file path. this is the xml string
+ */
+ public Diff getDiffForComparison(String xmlString) throws Exception {
+ return getDiffForComparison(new ByteArrayInputStream(xmlString.getBytes()));
+ }
+
+ public Diff getDiffForComparison(File xmlFile) throws Exception {
+ return getDiffForComparison(new FileInputStream(xmlFile));
+ }
+
+ public String getSerializedOM(String xmlString) throws Exception {
+ try {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+
+ ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(xmlString.getBytes());
+ StAXOMBuilder staxOMBuilder = OMXMLBuilderFactory.
+ createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
+ factory.createXMLStreamReader(byteArrayInputStream));
+ staxOMBuilder.setDoDebug(true);
+ OMElement rootElement = staxOMBuilder.getDocumentElement();
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+ OMOutputFormat format = new OMOutputFormat();
+ format.setIgnoreXMLDeclaration(ignoreXMLDeclaration);
+
+ ((OMDocument) rootElement.getParent()).serialize(baos, format);
+
+ return new String(baos.toByteArray());
+ } catch (Exception e) {
+ throw e;
+ }
+ }
+
+ public Diff getDiffForComparison(InputStream inStream) throws Exception {
+
+ try {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+
+ StAXOMBuilder staxOMBuilder = OMXMLBuilderFactory.
+ createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
+ factory.createXMLStreamReader(inStream));
+ staxOMBuilder.setDoDebug(true);
+ OMElement rootElement = staxOMBuilder.getDocumentElement();
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+
+ if (ignoreDocument) {
+ rootElement.serialize(baos);
+ } else {
+ ((OMDocument) rootElement.getParent()).serialize(baos);
+ }
+
+ InputSource resultXML = new InputSource(new InputStreamReader(
+ new ByteArrayInputStream(baos.toByteArray())));
+
+ Document dom2 = newDocument(resultXML);
+ Document dom1 = newDocument(inStream);
+
+ return compareXML(dom1, dom2);
+ } catch (XMLStreamException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (ParserConfigurationException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (SAXException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (IOException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ }
+ }
+
+ public Document newDocument(InputSource in)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ return db.parse(in);
+ }
+
+ public Document newDocument(InputStream in)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ return db.parse(in);
+ }
+
+ public Document newDocument(String xml)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ return db.parse(new ByteArrayInputStream(xml.getBytes()));
+ }
+
+ public String writeXmlFile(Document doc) {
+ try {
+ // Prepare the DOM document for writing
+ Source source = new DOMSource(doc);
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ Result result = new StreamResult(baos);
+
+ // Write the DOM document to the file
+ Transformer xformer = TransformerFactory.newInstance().newTransformer();
+ xformer.transform(source, result);
+ return new String(baos.toByteArray());
+ } catch (TransformerConfigurationException e) {
+ log.error(e.getMessage(), e);
+ } catch (TransformerException e) {
+ log.error(e.getMessage(), e);
+ }
+ return null;
+
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/AbstractTestCase.java b/test/org/apache/ws/commons/om/AbstractTestCase.java
new file mode 100644
index 0000000..e9eafc5
--- /dev/null
+++ b/test/org/apache/ws/commons/om/AbstractTestCase.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import junit.framework.TestCase;
+
+import java.io.File;
+
+/**
+ * Abstract base class for test cases.
+ */
+public abstract class AbstractTestCase
+ extends TestCase {
+ protected String testDir = "test" + File.separator;
+ protected String sampleDir = "samples" + File.separator;
+ protected String outDir = "target" + File.separator + "generated" +
+ File.separator +
+ "samples" +
+ File.separator;
+ protected String tempDir = "target" + File.separator + "generated" +
+ File.separator +
+ "temp";
+ protected String testResourceDir = "test-resources";
+
+ /**
+ * Basedir for all file I/O. Important when running tests from
+ * the reactor.
+ */
+ public String basedir = System.getProperty("basedir");
+
+ /**
+ * @param testName
+ */
+ public AbstractTestCase(String testName) {
+ super(testName);
+ if (basedir == null) {
+ basedir = new File(".").getAbsolutePath();
+ }
+ testDir = new File(basedir, testDir).getAbsolutePath();
+ sampleDir = new File(basedir, sampleDir).getAbsolutePath();
+ outDir = new File(basedir, outDir).getAbsolutePath();
+ tempDir = new File(basedir, tempDir).getAbsolutePath();
+ }
+
+ public File getTestResourceFile(String relativePath) {
+ return new File(testResourceDir, relativePath);
+ }
+
+ public File getTempOutputFile(String filename) {
+ File f = new File(tempDir);
+ if(!f.exists()) {
+ f.mkdirs();
+ }
+ return new File(f, filename);
+ }
+}
+
diff --git a/test/org/apache/ws/commons/om/AttrNsTest.java b/test/org/apache/ws/commons/om/AttrNsTest.java
new file mode 100644
index 0000000..3c8abb0
--- /dev/null
+++ b/test/org/apache/ws/commons/om/AttrNsTest.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.custommonkey.xmlunit.Diff;
+import org.w3c.dom.Document;
+
+import javax.xml.namespace.QName;
+import java.io.ByteArrayInputStream;
+
+public class AttrNsTest extends AbstractOMSerializationTest {
+
+ private String attrNamespaceTestXML = "<?xml version='1.0' encoding='UTF-8'?>\n" +
+ "<foo xmlns:a=\"http://opensource.lk\">" +
+ " <bar1 b:attr=\"test attr value1\" xmlns:b=\"http://opensource.lk/ns1\">test1</bar1>" +
+ " <bar2 b:attr=\"test attr value2\" xmlns:b=\"http://opensource.lk/ns1\">test2</bar2>" +
+ "</foo>";
+
+ public void testAttributeNamespaces() throws Exception {
+ ignoreXMLDeclaration = true;
+ ignoreDocument = true;
+
+ Document document1 = newDocument(attrNamespaceTestXML);
+ String serializedOM = getSerializedOM(attrNamespaceTestXML);
+ Document document2 = newDocument(serializedOM);
+
+ Diff diff = compareXML(document1, document2);
+ assertXMLEqual(diff, true);
+ }
+
+
+ /**
+ * Test method to test the XML namespace
+ * @throws Exception
+ */
+ public void testAttr() throws Exception{
+ String xml = "<wsp:Policy xml:base=\"uri:thisBase\" " +
+ "xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\">" +
+ "</wsp:Policy>";
+
+ ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes());
+ StAXOMBuilder builder = new StAXOMBuilder(bais);
+ OMElement elem = builder.getDocumentElement();
+ elem.build();
+ assertEquals("Attribute value mismatch", "uri:thisBase", elem.getAttributeValue(new QName(OMConstants.XMLNS_URI,"base")));
+
+ OMAttribute attr = elem.getAttribute(new QName(OMConstants.XMLNS_URI,"base"));
+
+ assertEquals("Attribute namespace mismatch", OMConstants.XMLNS_URI, attr.getNamespace().getName());
+ }
+
+ /**
+ * Test method to test the XML namespace of an attr without
+ * any other ns declarations in the element
+ * @throws Exception
+ */
+ public void testAttrWithoutElementNS() throws Exception{
+ String xml = "<Policy xml:base=\"uri:thisBase\"></Policy>";
+
+ ByteArrayInputStream bais = new ByteArrayInputStream(xml.getBytes());
+ StAXOMBuilder builder = new StAXOMBuilder(bais);
+ OMElement elem = builder.getDocumentElement();
+ elem.build();
+ assertEquals("Attribute value mismatch", "uri:thisBase", elem.getAttributeValue(new QName(OMConstants.XMLNS_URI,"base")));
+
+ OMAttribute attr = elem.getAttribute(new QName(OMConstants.XMLNS_URI,"base"));
+
+ assertEquals("Attribute namespace mismatch", OMConstants.XMLNS_URI, attr.getNamespace().getName());
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/BadInputTest.java b/test/org/apache/ws/commons/om/BadInputTest.java
new file mode 100644
index 0000000..eda38eb
--- /dev/null
+++ b/test/org/apache/ws/commons/om/BadInputTest.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPEnvelope;
+
+public class BadInputTest extends OMTestCase {
+
+ public BadInputTest(String testName) {
+ super(testName);
+ }
+
+
+ //done
+ public void testEnvelopeMissing() throws Exception {
+ try {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.BAD_ENVELOPE_MISSING))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ fail("this must failed gracefully with OMException or AxisFault");
+ } catch (OMException e) {
+ return;
+ }
+
+ }
+
+ //done
+ public void testHeaderBodyWrongOrder() throws Exception {
+ try {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.BAD_HEADER_BODY_WRONG_ORDER))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ fail("this must failed gracefully with OMException or AxisFault");
+ } catch (OMException e) {
+ return;
+ }
+ }
+
+ //done
+ // public void testNotnamespaceQualified() throws Exception {
+ // try {
+ // SOAPEnvelope soapEnvelope =
+ // (SOAPEnvelope) OMTestUtils.getOMBuilder(new File(dir, "notnamespaceQualified.xml")).getDocumentElement();
+ // OMTestUtils.walkThrough(soapEnvelope);
+ // fail("this must failed gracefully with OMException or AxisFault");
+ // } catch (OMException e) {
+ // return;
+ // } catch (AxisFault e) {
+ // return;
+ // }
+ //
+ // }
+ //done
+ // public void testBodyNotQualified() throws Exception {
+ // try {
+ // SOAPEnvelope soapEnvelope =
+ // (SOAPEnvelope) OMTestUtils.getOMBuilder(new File(dir, "bodyNotQualified.xml")).getDocumentElement();
+ // OMTestUtils.walkThrough(soapEnvelope);
+ // fail("this must failed gracefully with OMException or AxisFault");
+ // } catch (OMException e) {
+ // //we are OK!
+ // return;
+ // } catch (AxisFault e) {
+ // //we are OK here too!
+ // return;
+ // }
+ //
+ // }
+
+ //done
+ public void testTwoBodymessage() throws Exception {
+ try {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.BAD_TWO_BODY))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ fail("this must failed gracefully with OMException or AxisFault");
+ } catch (OMException e) {
+ return;
+ }
+
+ }
+
+ //done
+ public void testTwoheaders() throws Exception {
+ try {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.BAD_TWO_HEADERS))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ fail("this must failed gracefully with OMException or AxisFault");
+ } catch (OMException e) {
+ return;
+ }
+
+ }
+
+ //done
+ public void testWrongSoapNs() throws Exception {
+ try {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.BAD_WRONG_SOAP_NS))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ fail("this must failed gracefully with OMException or AxisFault");
+ } catch (OMException e) {
+ return;
+ }
+
+ }
+
+
+
+
+}
diff --git a/test/org/apache/ws/commons/om/CompareOMWithDOMTest.java b/test/org/apache/ws/commons/om/CompareOMWithDOMTest.java
new file mode 100644
index 0000000..0a35403
--- /dev/null
+++ b/test/org/apache/ws/commons/om/CompareOMWithDOMTest.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.w3c.dom.Document;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.File;
+
+/**
+ * @version $Rev: $ $Date: $
+ */
+public class CompareOMWithDOMTest extends AbstractTestCase {
+ /**
+ * @param testName
+ */
+ public CompareOMWithDOMTest(String testName) {
+ super(testName);
+ }
+
+ public void testAllMessagesInSOAP() throws OMException, Exception {
+ File dir = new File(testResourceDir, "soap");
+ File[] files = dir.listFiles();
+ if (files != null) {
+ for (int i = 0; i < files.length; i++) {
+ if (files[i].isFile() && files[i].getName().endsWith(".xml") && !files[i].getName().startsWith("wrong")) {
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ files[i])
+ .getDocumentElement();
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder builder = dbf.newDocumentBuilder();
+ Document doc = builder.parse(files[i].getAbsolutePath());
+ OMTestUtils.compare(doc.getDocumentElement(),
+ soapEnvelope);
+ }
+ }
+
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/om/DefaultNamespaceTest.java b/test/org/apache/ws/commons/om/DefaultNamespaceTest.java
new file mode 100644
index 0000000..1a090a6
--- /dev/null
+++ b/test/org/apache/ws/commons/om/DefaultNamespaceTest.java
@@ -0,0 +1,52 @@
+package org.apache.ws.commons.om;
+
+import org.custommonkey.xmlunit.XMLTestCase;
+
+import javax.xml.namespace.QName;
+
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ *
+ */
+
+public class DefaultNamespaceTest extends XMLTestCase {
+
+ public void testDefaultNamespace() throws Exception {
+
+ String expectedXML = "<Foo xmlns=\"http://defaultNsUri.org\"><Bar xmlns=\"\"></Bar><Baz></Baz></Foo>";
+
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMElement foo = factory.createOMElement(new QName("http://defaultNsUri.org", "Foo"), null);
+ factory.createOMElement("Bar", null, foo);
+ factory.createOMElement(new QName("http://defaultNsUri.org", "Baz"), foo);
+ assertXMLEqual(expectedXML, foo.toString());
+ }
+
+ public void test() {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+
+ String nsURI = "http://test.org";
+ String nsPrefix = "testPrefix";
+ OMElement element = factory.createOMElement("DocElement", null);
+
+ OMElement foo = factory.createOMElement(new QName(nsURI, "Foo", nsPrefix), element);
+ factory.createOMElement(new QName(nsURI+1, "Bar", nsPrefix), element);
+
+ factory.createOMElement(new QName(nsURI+2, "Baz", nsPrefix), foo);
+ factory.createOMElement(new QName(nsURI, "Baz", nsPrefix), foo);
+
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/IteratorTest.java b/test/org/apache/ws/commons/om/IteratorTest.java
new file mode 100644
index 0000000..0540c18
--- /dev/null
+++ b/test/org/apache/ws/commons/om/IteratorTest.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.factory.OMLinkedListImplFactory;
+
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import java.io.FileReader;
+import java.util.Iterator;
+
+public class IteratorTest extends AbstractTestCase {
+ private OMElement envelope = null;
+
+ public IteratorTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ //lets use a plain OM factory
+ envelope =
+ new StAXOMBuilder(new OMLinkedListImplFactory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile(
+ "soap/soapmessage1.xml")))).getDocumentElement();
+ }
+
+ protected void tearDown() throws Exception {
+ envelope = null;
+ }
+
+ /**
+ * Test the plain iterator which includes all the
+ * children (including the texts)
+ */
+ public void testIterator() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildren();
+ int counter = 0;
+ while (iter.hasNext()) {
+ counter ++;
+ assertNotNull("Must return not null objects!",iter.next());
+ }
+ assertEquals("This element should contain only five children including the text ",5,counter);
+ }
+
+ /**
+ * Test the element iterator
+ */
+ public void testElementIterator() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildElements();
+ int counter = 0;
+ while (iter.hasNext()) {
+ counter ++;
+ Object o = iter.next();
+ assertNotNull("Must return not null objects!",o);
+ assertTrue("All these should be elements!",((OMNode)o).getType()==OMNode.ELEMENT_NODE);
+ }
+ assertEquals("This element should contain only two elements ",2,counter);
+ }
+
+ /**
+ * Test the element iterator
+ */
+ public void testElementQNameIterator() {
+ OMElement elt = envelope;
+ QName qname = new QName("http://schemas.xmlsoap.org/soap/envelope/","body");
+ Iterator iter = elt.getChildrenWithName(qname);
+ int counter = 0;
+ while (iter.hasNext()) {
+ counter ++;
+ Object o = iter.next();
+ assertNotNull("Must return not null objects!",o);
+ assertTrue("All these should be elements!",((OMNode)o).getType()==OMNode.ELEMENT_NODE);
+ }
+ assertEquals("This element should contain only one element with the given QName ",1,counter);
+ }
+
+ /**
+ * test the remove exception behavior
+ */
+ public void testIteratorRemove1() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildren();
+
+ //this is supposed to throw an illegal state exception
+ try {
+ iter.remove();
+ fail("remove should throw an exception");
+ } catch (IllegalStateException e) {
+ //ok. this is what should happen
+ }
+
+ }
+
+ /**
+ * test the remove exception behavior, consecutive remove calls
+ */
+ public void testIteratorRemove2() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildren();
+ if (iter.hasNext()) {
+ iter.next();
+ }
+ iter.remove();
+
+ //this call must generate an exception
+ try {
+ iter.remove();
+ fail("calling remove twice without a call to next is prohibited");
+ } catch (IllegalStateException e) {
+ //ok if we come here :)
+ }
+
+ }
+
+ /**
+ * Remove all!
+ */
+ public void testIteratorRemove3() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildren();
+ while (iter.hasNext()) {
+ iter.next();
+ iter.remove();
+ }
+ iter = elt.getChildren();
+ if (iter.hasNext()) {
+ //we shouldn't reach here!
+ fail("No children should remain after removing all!");
+ }
+
+
+ }
+
+ /**
+ * test whether the children count reduces.
+ */
+ public void testIteratorRemove4() {
+ OMElement elt = envelope;
+ Iterator iter = elt.getChildren();
+ int firstChildrenCount = 0;
+ int secondChildrenCount = 0;
+ while (iter.hasNext()) {
+ assertNotNull(iter.next());
+ firstChildrenCount++;
+ }
+
+ //remove the last node
+ iter.remove();
+
+ //reloop and check the count
+ //Note- here we should get a fresh iterator since there is no method to
+ //reset the iterator
+ iter = elt.getChildren(); //reset the iterator
+ while (iter.hasNext()) {
+ assertNotNull(iter.next());
+ secondChildrenCount++;
+ }
+ assertEquals("children count must reduce from 1",
+ firstChildrenCount - 1,
+ secondChildrenCount);
+
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/MIMEOutputUtilsTest.java b/test/org/apache/ws/commons/om/MIMEOutputUtilsTest.java
new file mode 100644
index 0000000..9986b2c
--- /dev/null
+++ b/test/org/apache/ws/commons/om/MIMEOutputUtilsTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.attachments.ByteArrayDataSource;
+import org.apache.ws.commons.om.impl.MIMEOutputUtils;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPFactory;
+
+import javax.activation.DataHandler;
+import javax.mail.MessagingException;
+import javax.mail.internet.MimeBodyPart;
+import javax.mail.internet.MimeMessage;
+import javax.mail.internet.MimeMultipart;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Properties;
+
+public class MIMEOutputUtilsTest extends TestCase {
+ byte[] buffer;
+ byte[] byteArray = new byte[]{13, 56, 65, 32, 12, 12, 7, -3, -2, -1,
+ 98};
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ SOAPFactory factory = OMAbstractFactory.getSOAP11Factory();
+ ByteArrayOutputStream outStream;
+ String boundary;
+
+ OMOutputFormat omOutput = new OMOutputFormat();
+ boundary = omOutput.getMimeBoundary();
+
+ String contentType = org.apache.ws.commons.om.impl.MIMEOutputUtils
+ .getContentTypeForMime(boundary, omOutput.getRootContentId(),
+ omOutput.getCharSetEncoding(),SOAP12Constants.SOAP_12_CONTENT_TYPE);
+ DataHandler dataHandler;
+ dataHandler = new DataHandler(new ByteArrayDataSource(byteArray));
+ OMText textData = factory.createText(dataHandler, true);
+ assertNotNull(textData.getContentID());
+
+ DataHandler dataHandler2 = new DataHandler(
+ "Apache Software Foundation", "text/plain");
+ OMText text = factory.createText(dataHandler2, true);
+ assertNotNull(text.getContentID());
+ outStream = new ByteArrayOutputStream();
+ outStream.write(("Content-Type: " + contentType).getBytes());
+ outStream.write(new byte[]{13,10});
+ outStream.write(new byte[]{13,10});
+
+ MIMEOutputUtils.startWritingMime(outStream, boundary);
+ MimeBodyPart part1 = MIMEOutputUtils.createMimeBodyPart(textData);
+ MIMEOutputUtils.writeBodyPart(outStream, part1, boundary);
+ MimeBodyPart part2 = MIMEOutputUtils.createMimeBodyPart(text);
+ MIMEOutputUtils.writeBodyPart(outStream, part2, boundary);
+ MIMEOutputUtils.finishWritingMime(outStream);
+ buffer = outStream.toByteArray();
+ }
+
+ public void testMIMEWriting() throws IOException, MessagingException {
+ ByteArrayInputStream inStream = new ByteArrayInputStream(buffer);
+ Properties props = new Properties();
+ javax.mail.Session session = javax.mail.Session
+ .getInstance(props, null);
+ MimeMessage mimeMessage = new MimeMessage(session, inStream);
+ DataHandler dh = mimeMessage.getDataHandler();
+ MimeMultipart multiPart = new MimeMultipart(dh.getDataSource());
+ MimeBodyPart mimeBodyPart0 = (MimeBodyPart) multiPart.getBodyPart(0);
+ Object object0 = mimeBodyPart0.getContent();
+ assertNotNull(object0);
+ MimeBodyPart mimeBodyPart1 = (MimeBodyPart) multiPart.getBodyPart(1);
+ Object object1 = mimeBodyPart1.getContent();
+ assertNotNull(object1);
+ assertEquals(multiPart.getCount(),2);
+ }
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/om/MessagesTest.java b/test/org/apache/ws/commons/om/MessagesTest.java
new file mode 100644
index 0000000..7f11a09
--- /dev/null
+++ b/test/org/apache/ws/commons/om/MessagesTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPEnvelope;
+
+public class MessagesTest extends OMTestCase {
+ SOAPEnvelope soapEnvelope;
+
+ public MessagesTest(String testName) {
+ super(testName);
+ }
+
+ public void testMessageWithLotOfWhiteSpaces() throws OMException,
+ Exception {
+ soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.WHITESPACE_MESSAGE))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ }
+
+ public void testMinimalMessage() throws OMException, Exception {
+ soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.MINIMAL_MESSAGE))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ }
+
+ public void testReallyBigMessage() throws OMException, Exception {
+ soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.REALLY_BIG_MESSAGE))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ }
+
+ public void testEmptyBodiedMessage() throws OMException, Exception {
+ soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.EMPTY_BODY_MESSAGE))
+ .getDocumentElement();
+ OMTestUtils.walkThrough(soapEnvelope);
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/OMBlankElementTest.java b/test/org/apache/ws/commons/om/OMBlankElementTest.java
new file mode 100644
index 0000000..003ff24
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMBlankElementTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import junit.framework.TestCase;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.StringWriter;
+
+
+public class OMBlankElementTest extends TestCase {
+
+
+ public OMBlankElementTest(String name) {
+ super(name);
+ }
+
+ public void testBlankOMElem() {
+ try {
+ //We should not get anything as the return value here: the output of the serialization
+ String value = buildBlankOMElem();
+ assertNull("There's a serialized output for a blank XML element that cannot exist", value);
+ } catch (Exception e) {
+ //An exception is thrown trying to serializeAndConsume a blank element
+ assertTrue(true);
+ }
+ }
+
+
+
+ String buildBlankOMElem() throws XMLStreamException {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace namespace1 = factory.createOMNamespace("","");
+ OMElement elem1 = factory.createOMElement("",namespace1);
+
+ StringWriter writer = new StringWriter();
+ elem1.build();
+ elem1.serialize(writer);
+ writer.flush();
+ return writer.toString();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/OMBodyTest.java b/test/org/apache/ws/commons/om/OMBodyTest.java
new file mode 100644
index 0000000..8318115
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMBodyTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class OMBodyTest extends OMTestCase implements OMConstants {
+ SOAPBody soapBody;
+ private Log log = LogFactory.getLog(getClass());
+
+ public OMBodyTest(String testName) {
+ super(testName);
+ }
+
+ /*
+ * @see TestCase#setUp()
+ */
+ protected void setUp() throws Exception {
+ super.setUp();
+ soapBody = soapEnvelope.getBody();
+ }
+
+ /*
+ * Class under test for SOAPFault addFault()
+ */
+ public void testAddFault() {
+ log.info("Adding SOAP fault to body ....");
+ try {
+ soapBody.addChild(
+ soapFactory.createSOAPFault(soapBody,
+ new Exception("Testing soap fault")));
+ } catch (SOAPProcessingException e) {
+ log.info(e.getMessage());
+ fail(e.getMessage());
+ }
+ log.info("\t checking for SOAP Fault ...");
+ assertTrue("SOAP body has no SOAP fault", soapBody.hasFault());
+ log.info("\t checking for not-nullity ...");
+ assertTrue("SOAP body has no SOAP fault", soapBody.getFault() != null);
+
+ //SimpleOMSerializer simpleOMSerializer = new SimpleOMSerializer();
+ //simpleOMSerializer.serializeAndConsume(soapBody, System.out);
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/OMDocumentTest.java b/test/org/apache/ws/commons/om/OMDocumentTest.java
new file mode 100644
index 0000000..b84546e
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMDocumentTest.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayOutputStream;
+import java.io.StringReader;
+import java.util.Iterator;
+
+public class OMDocumentTest extends TestCase {
+ private String sampleXML = "<?xml version='1.0' encoding='utf-8'?>" +
+ "<!--This is some comments at the start of the document-->" +
+ "<?PITarget PIData?>" +
+ "<Axis2>" +
+ " <ProjectName>The Apache Web Sevices Project</ProjectName>" +
+ "</Axis2>";
+
+ public void testOMDocument() throws XMLStreamException {
+ // read the string in to the builder
+ OMDocument omDocument = getSampleOMDocument(sampleXML);
+
+ // serialise it to a string
+ String outXML = "";
+ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+ omDocument.serializeAndConsume(outStream);
+ outXML = new String(outStream.toByteArray());
+
+ // again load that to another builder
+ OMDocument secondDocument = getSampleOMDocument(outXML);
+
+ // check for the comment and the PI
+ boolean commentFound = false;
+ boolean piFound = false;
+ Iterator children = secondDocument.getChildren();
+ while (children.hasNext()) {
+ OMNode omNode = (OMNode) children.next();
+ if (omNode instanceof OMComment) {
+ commentFound = true;
+ } else if (omNode instanceof OMProcessingInstruction) {
+ piFound = true;
+ } else if (omNode instanceof OMElement && !commentFound && !piFound) {
+ fail("OMElement should come after Comment and PI");
+
+ }
+ }
+ assertTrue(commentFound && piFound);
+
+
+ }
+
+ private OMDocument getSampleOMDocument(String xml) {
+ try {
+ XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().createXMLStreamReader(new StringReader(xml));
+ StAXOMBuilder builder = new StAXOMBuilder(xmlStreamReader);
+ return builder.getDocument();
+ } catch (XMLStreamException e) {
+ throw new UnsupportedOperationException();
+ }
+ }
+
+// private OMDocument getSampleOMDocument() {
+// OMFactory omFactory = OMAbstractFactory.getOMFactory();
+// OMDocument omDocument = omFactory.createOMDocument();
+// omFactory.createOMComment(omDocument, "This is some comments at the start of the document");
+// omDocument.setCharsetEncoding("utf-8");
+// omFactory.createOMProcessingInstruction(omDocument, "PITarget", "PIData");
+//
+// OMElement documentElement = omFactory.createOMElement("Axis2", null, omDocument);
+// omDocument.setDocumentElement(documentElement);
+// omFactory.createOMElement("ProjectName", null, documentElement);
+// documentElement.getFirstElement().setText("The Apache Web Sevices Project");
+//
+// return omDocument;
+// }
+
+}
diff --git a/test/org/apache/ws/commons/om/OMElementCloneTest.java b/test/org/apache/ws/commons/om/OMElementCloneTest.java
new file mode 100644
index 0000000..2b8f5d0
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMElementCloneTest.java
@@ -0,0 +1,89 @@
+package org.apache.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.custommonkey.xmlunit.XMLTestCase;
+import org.w3c.dom.Document;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.IOException;
+
+/*
+ * Copyright 2001-2004 The Apache Software Foundation.
+ *
+ * Licensed 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.
+ *
+ */
+
+public class OMElementCloneTest extends XMLTestCase {
+
+ File dir = new File(TestConstants.TEST_RESOURCES, TestConstants.SOAP_DIR);
+
+ public void testElementCloningWithoutUsingOMElementMethod() throws Exception {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ new File(dir, TestConstants.SOAPMESSAGE))
+ .getDocumentElement();
+ SOAPBody body = soapEnvelope.getBody();
+
+ OMElement firstClonedBodyElement = new StAXOMBuilder(body.getXMLStreamReader()).getDocumentElement();
+ OMElement secondClonedBodyElement = new StAXOMBuilder(body.getXMLStreamReader()).getDocumentElement();
+
+ // first check whether both have the same information
+ assertXMLEqual(newDocument(body.toString()), newDocument(firstClonedBodyElement.toString()));
+ assertXMLEqual(newDocument(body.toString()), newDocument(secondClonedBodyElement.toString()));
+ assertXMLEqual(newDocument(firstClonedBodyElement.toString()), newDocument(secondClonedBodyElement.toString()));
+
+ // lets check some links. They must not be equal
+ assertNotSame(body.getParent(), firstClonedBodyElement.getParent());
+ assertNotSame(body.getParent(), secondClonedBodyElement.getParent());
+ assertNotSame(firstClonedBodyElement.getParent(), secondClonedBodyElement.getParent());
+
+ }
+
+ public void testElementCloningUsingOMElementMethod() throws Exception {
+ SOAPEnvelope soapEnvelope =
+ (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ new File(dir, TestConstants.SOAPMESSAGE))
+ .getDocumentElement();
+ SOAPBody body = soapEnvelope.getBody();
+
+ OMElement firstClonedBodyElement = body.cloneOMElement();
+ OMElement secondClonedBodyElement = body.cloneOMElement();
+
+ // first check whether both have the same information
+ assertXMLEqual(newDocument(body.toString()), newDocument(firstClonedBodyElement.toString()));
+ assertXMLEqual(newDocument(body.toString()), newDocument(secondClonedBodyElement.toString()));
+ assertXMLEqual(newDocument(firstClonedBodyElement.toString()), newDocument(secondClonedBodyElement.toString()));
+
+ // lets check some links. They must not be equal
+ assertNotSame(body.getParent(), firstClonedBodyElement.getParent());
+ assertNotSame(body.getParent(), secondClonedBodyElement.getParent());
+ assertNotSame(firstClonedBodyElement.getParent(), secondClonedBodyElement.getParent());
+
+ }
+
+ public Document newDocument(String xml)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ return db.parse(new ByteArrayInputStream(xml.getBytes()));
+ }
+}
diff --git a/test/org/apache/ws/commons/om/OMElementQNameTest.java b/test/org/apache/ws/commons/om/OMElementQNameTest.java
new file mode 100644
index 0000000..ca1a813
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMElementQNameTest.java
@@ -0,0 +1,88 @@
+/** (C) Copyright 2005 Hewlett-Packard Development Company, LP
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ For more information: www.smartfrog.org
+
+ */
+package org.apache.ws.commons.om;
+
+import org.apache.ws.commons.om.util.ElementHelper;
+
+import javax.xml.namespace.QName;
+
+/**
+ * created 03-Nov-2005 11:46:32
+ */
+
+public class OMElementQNameTest extends OMTestCase {
+
+ OMElement element;
+
+ private static final String WSA= "http://schemas.xmlsoap.org/ws/2004/03/addressing";
+ private static final String SOAPENV = "http://schemas.xmlsoap.org/soap/envelope/";
+
+ public OMElementQNameTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ element = OMTestUtils.getOMBuilder(
+ getTestResourceFile(TestConstants.SOAP_SOAPMESSAGE1))
+ .getDocumentElement();
+ }
+
+ public void testSimpleQName() throws Exception {
+ QName result = element.resolveQName("wsa:To");
+ assertEquals(WSA,result.getNamespaceURI());
+ assertEquals("wsa", result.getPrefix());
+ assertEquals("To", result.getLocalPart());
+ }
+
+ public void testDefaultQName() throws Exception {
+ QName result = element.resolveQName("localonly");
+ assertEquals(SOAPENV, result.getNamespaceURI());
+ assertEquals("soapenv", result.getPrefix());
+ assertEquals("localonly", result.getLocalPart());
+ }
+
+ public void testDefaultQNameCanBeLocal() throws Exception {
+ ElementHelper helper=new ElementHelper(element);
+ QName result = helper.resolveQName("localonly",false);
+ assertEquals("", result.getNamespaceURI());
+ assertEquals("localonly", result.getLocalPart());
+ }
+
+ public void testNoLocal() throws Exception {
+ assertResolvesToNull("wsa:");
+ }
+
+ public void testNoMatch() throws Exception {
+ assertResolvesToNull("wsa2005:To");
+ }
+
+ public void testNothing() throws Exception {
+ assertResolvesToNull(":");
+ }
+
+
+
+ private void assertResolvesToNull(String qname) {
+ QName result = element.resolveQName(qname);
+ assertNull("Expected "+qname+" to resolve to null",result);
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/OMNavigatorTest.java b/test/org/apache/ws/commons/om/OMNavigatorTest.java
new file mode 100644
index 0000000..12070e0
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMNavigatorTest.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.OMNavigator;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+
+public class OMNavigatorTest extends AbstractTestCase {
+ private SOAPEnvelope envelope = null;
+ private OMXMLParserWrapper builder;
+ private File tempFile;
+ private XMLStreamWriter output;
+
+ public OMNavigatorTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile(TestConstants.SOAP_SOAPMESSAGE1)));
+ builder = new StAXSOAPModelBuilder(xmlStreamReader, null);
+ envelope = (SOAPEnvelope) builder.getDocumentElement();
+ tempFile = File.createTempFile("temp", "xml");
+ output =
+ XMLOutputFactory.newInstance().createXMLStreamWriter(
+ new FileOutputStream(tempFile));
+ }
+
+ public void testnavigatorFullyBuilt() throws Exception {
+ assertNotNull(envelope);
+ //dump the out put to a temporary file
+ envelope.serialize(output);
+
+ //now the OM is fully created -> test the navigation
+ OMNavigator navigator = new OMNavigator(envelope);
+ OMNode node = null;
+ while (navigator.isNavigable()) {
+ node = navigator.next();
+ assertNotNull(node);
+ }
+ }
+
+ public void testnavigatorHalfBuilt() {
+ assertNotNull(envelope);
+ //now the OM is not fully created. Try to navigate it
+ OMNavigator navigator = new OMNavigator(envelope);
+ OMNode node = null;
+ while (navigator.isNavigable()) {
+ node = navigator.next();
+ assertNotNull(node);
+ }
+ }
+
+ public void testnavigatorHalfBuiltStep() {
+ assertNotNull(envelope);
+
+ //now the OM is not fully created
+ OMNavigator navigator = new OMNavigator(envelope);
+ OMNode node = null;
+ while (!navigator.isCompleted()) {
+ if (navigator.isNavigable()) {
+ node = navigator.next();
+ } else {
+ builder.next();
+ navigator.step();
+ node = navigator.next();
+ }
+ assertNotNull(node);
+
+ }
+
+ }
+
+ protected void tearDown() throws Exception {
+ tempFile.delete();
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/OMTest.java b/test/org/apache/ws/commons/om/OMTest.java
new file mode 100644
index 0000000..64617bf
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMTest.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.Iterator;
+
+/**
+ * This test case tests the basic expectations of the engine from the OM.
+ */
+public class OMTest extends AbstractTestCase {
+ private SOAPEnvelope envelope;
+
+ /**
+ * Constructor.
+ */
+ public OMTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ File file = getTestResourceFile(TestConstants.SAMPLE1);
+ XMLStreamReader parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new FileReader(file));
+ OMXMLParserWrapper builder = new StAXSOAPModelBuilder(parser, null);
+ envelope = (SOAPEnvelope) builder.getDocumentElement();
+ }
+
+ /**
+ * Sometime the hasNext() in the childeren iterator is true yet the next() is null
+ */
+ public void testNullInChilderen() {
+ isNullChildrenThere(envelope);
+ }
+
+ /**
+ * the envelope is completly namesapce qulified so all the OMElements got to have namespace values not null
+ */
+ public void test4MissingNamespaces() {
+ isNameSpacesMissing(envelope);
+ }
+
+ public void isNullChildrenThere(OMElement omeleent) {
+ Iterator it = omeleent.getChildren();
+ while (it.hasNext()) {
+ OMNode node = (OMNode) it.next();
+ assertNotNull(node);
+ if (node.getType() == OMNode.ELEMENT_NODE) {
+ isNullChildrenThere((OMElement) node);
+ }
+ }
+ }
+
+ public void isNameSpacesMissing(OMElement omeleent) {
+ OMNamespace omns = omeleent.getNamespace();
+ assertNotNull(omns);
+ assertNotNull(omns.getName());
+ Iterator it = omeleent.getChildren();
+ while (it.hasNext()) {
+ OMNode node = (OMNode) it.next();
+ if (node != null && node.getType() == OMNode.ELEMENT_NODE) {
+ isNameSpacesMissing((OMElement) node);
+ }
+ }
+ }
+
+ public void testRootNotCompleteInPartialBuild() throws Exception {
+ assertFalse("Root should not be complete", envelope.isComplete());
+ }
+
+ /**
+ * Assumption - The fed XML has at least two children under the root element
+ *
+ * @throws Exception
+ */
+ public void testFirstChildDetach() throws Exception {
+ OMElement root = envelope;
+ assertFalse("Root should not be complete", root.isComplete());
+ OMNode oldFirstChild = root.getFirstOMChild();
+ assertNotNull(oldFirstChild);
+ oldFirstChild.detach();
+ OMNode newFirstChild = root.getFirstOMChild();
+ assertNotNull(newFirstChild);
+ assertNotSame(oldFirstChild, newFirstChild);
+ }
+
+ //todo this is wrong correct this
+ public void testAdditionOfaCompletelyNewElement() throws Exception {
+
+ // OMElement root= envelope;
+ //
+ // OMNamespace soapenv= root.findNamespace("http://schemas.xmlsoap.org/soap/envelope/", "soapenv");
+ // OMNamespace wsa= root.findNamespace("http://schemas.xmlsoap.org/ws/2004/03/addressing", "wsa");
+ // if (wsa==null)
+ // wsa= root.declareNamespace("http://schemas.xmlsoap.org/ws/2004/03/addressing", "wsa");
+ //
+ // //Assumption - A RelatesTo Element does not exist in the input document
+ // OMElement relatesTo= fac.createOMElement ("RelatesTo", wsa);
+ // relatesTo.addAttribute(fac.createOMAttribute("RelationshipType", null, "wsa:Reply", relatesTo));
+ // relatesTo.addAttribute(fac.createOMAttribute("mustUnderstand", soapenv, "0", relatesTo));
+ // relatesTo.addChild(fac.createText(relatesTo, "uuid:3821F4F0-D020-11D8-A10A-E4EE6425FCB0"));
+ // relatesTo.setComplete(true);
+ //
+ // root.addChild(relatesTo);
+ //
+ // QName name = new QName(wsa.getName(),"RelatesTo",wsa.getPrefix());
+ //
+ // Iterator children = root.getChildrenWithName(name);
+ // //this should contain only one child!
+ // if (children.hasNext()){
+ // OMElement newlyAddedElement = (OMElement)children.next();
+ //
+ // assertNotNull(newlyAddedElement);
+ //
+ // assertEquals(newlyAddedElement.getLocalName(),"RelatesTo");
+ // //todo put the other assert statements here
+ // }else{
+ // assertFalse("New child not added",true);
+ // }
+
+ }
+}
diff --git a/test/org/apache/ws/commons/om/OMTestCase.java b/test/org/apache/ws/commons/om/OMTestCase.java
new file mode 100644
index 0000000..4348755
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMTestCase.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.FileReader;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public abstract class OMTestCase extends AbstractTestCase {
+ protected StAXSOAPModelBuilder builder;
+ protected OMFactory ombuilderFactory;
+ protected SOAPFactory soapFactory;
+
+ protected SOAPEnvelope soapEnvelope;
+
+ public OMTestCase(String testName) {
+ super(testName);
+ ombuilderFactory = OMAbstractFactory.getOMFactory();
+ soapFactory = OMAbstractFactory.getSOAP11Factory();
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soapEnvelope = (SOAPEnvelope) getOMBuilder("").getDocumentElement();
+ }
+
+ protected StAXSOAPModelBuilder getOMBuilder(String fileName) throws Exception {
+ if ("".equals(fileName) || fileName == null) {
+ fileName = TestConstants.SOAP_SOAPMESSAGE;
+ }
+ XMLStreamReader parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(
+ new FileReader(getTestResourceFile(fileName)));
+ builder = new StAXSOAPModelBuilder(parser, null);
+ return builder;
+ }
+
+ protected StAXSOAPModelBuilder getOMBuilder(InputStream in) throws Exception {
+ XMLStreamReader parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(in);
+ builder = new StAXSOAPModelBuilder(parser, null);
+ return builder;
+ }
+
+ protected XMLStreamWriter getStAXStreamWriter(OutputStream out) throws XMLStreamException {
+ return XMLOutputFactory.newInstance().createXMLStreamWriter(out);
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/OMTestUtils.java b/test/org/apache/ws/commons/om/OMTestUtils.java
new file mode 100644
index 0000000..a69e419
--- /dev/null
+++ b/test/org/apache/ws/commons/om/OMTestUtils.java
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.Iterator;
+
+public class OMTestUtils {
+ public static OMXMLParserWrapper getOMBuilder(File file) throws Exception {
+ XMLStreamReader parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new FileReader(file));
+ return OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(), parser);
+ }
+
+ public static void walkThrough(OMElement omEle) {
+ Iterator attibIt = omEle.getAllAttributes();
+ if (attibIt != null) {
+ while (attibIt.hasNext()) {
+ TestCase.assertNotNull("once the has next is not null, the " +
+ "element should not be null",
+ attibIt.next());
+ }
+ }
+ Iterator it = omEle.getChildren();
+ if (it != null) {
+ while (it.hasNext()) {
+ OMNode ele = (OMNode) it.next();
+ TestCase.assertNotNull("once the has next is not null, the " +
+ "element should not be null", ele);
+ if (ele instanceof OMElement) {
+ walkThrough((OMElement) ele);
+ }
+ }
+ }
+ }
+
+ public static void compare(Element ele, OMElement omele) throws Exception {
+ if (ele == null && omele == null) {
+ return;
+ } else if (ele != null && omele != null) {
+ TestCase.assertEquals("Element name not correct",
+ ele.getLocalName(),
+ omele.getLocalName());
+ if (omele.getNamespace() != null) {
+ TestCase.assertEquals("Namespace URI not correct",
+ ele.getNamespaceURI(),
+ omele.getNamespace().getName());
+
+ }
+
+ //go through the attributes
+ NamedNodeMap map = ele.getAttributes();
+ Iterator attIterator = omele.getAllAttributes();
+ OMAttribute omattribute;
+ while (attIterator != null && attIterator.hasNext() && map == null) {
+ omattribute = (OMAttribute) attIterator.next();
+ Node node = map.getNamedItemNS(
+ omattribute.getNamespace().getName(),
+ omattribute.getLocalName());
+ if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
+ Attr attr = (Attr) node;
+ TestCase.assertEquals(attr.getValue(),
+ omattribute.getAttributeValue());
+ } else {
+ throw new OMException("return type is not a Attribute");
+ }
+
+ }
+ Iterator it = omele.getChildren();
+ NodeList list = ele.getChildNodes();
+ for (int i = 0; i < list.getLength(); i++) {
+ Node node = list.item(i);
+ if (node.getNodeType() == Node.ELEMENT_NODE) {
+ TestCase.assertTrue(it.hasNext());
+ OMNode tempOmNode = (OMNode) it.next();
+ while (tempOmNode.getType() != OMNode.ELEMENT_NODE) {
+ TestCase.assertTrue(it.hasNext());
+ tempOmNode = (OMNode) it.next();
+ }
+ compare((Element) node, (OMElement) tempOmNode);
+ }
+ }
+
+
+ } else {
+ throw new Exception("One is null");
+ }
+ }
+
+ public static SOAPEnvelope createOM(File file) throws Exception {
+ return (SOAPEnvelope) getOMBuilder(file).getDocumentElement();
+ }
+
+}
diff --git a/test/org/apache/ws/commons/om/SpacesTest.java b/test/org/apache/ws/commons/om/SpacesTest.java
new file mode 100644
index 0000000..8df59ed
--- /dev/null
+++ b/test/org/apache/ws/commons/om/SpacesTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.custommonkey.xmlunit.Diff;
+import org.custommonkey.xmlunit.XMLTestCase;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class SpacesTest extends XMLTestCase {
+ private String filePath = "test-resources/xml/spaces.xml";
+
+
+ private OMElement rootElement;
+
+ protected void setUp() throws Exception {
+ }
+
+ public void testCData() throws Exception {
+ checkOMConformance(new FileInputStream(filePath));
+ }
+
+ private void checkOMConformance(InputStream iStream) throws Exception {
+ try {
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+
+ StAXOMBuilder staxOMBuilder = OMXMLBuilderFactory.
+ createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
+ factory.createXMLStreamReader(
+ iStream));
+ staxOMBuilder.setDoDebug(true);
+ rootElement = staxOMBuilder.getDocumentElement();
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ ((OMDocument) rootElement.getParent()).serialize(baos);
+
+ InputSource resultXML = new InputSource(new InputStreamReader(
+ new ByteArrayInputStream(baos.toByteArray())));
+
+ Document dom1 = newDocument(new InputSource(new FileInputStream(filePath)));
+ Document dom2 = newDocument(resultXML);
+
+ Diff diff = compareXML(dom1, dom2);
+ assertXMLEqual(diff, true);
+ } catch (XMLStreamException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (ParserConfigurationException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (SAXException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ } catch (IOException e) {
+ fail(e.getMessage());
+ throw new Exception(e);
+ }
+ }
+
+ public Document newDocument(InputSource in)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ return db.parse(in);
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/StaxParserTest.java b/test/org/apache/ws/commons/om/StaxParserTest.java
new file mode 100644
index 0000000..d445ac9
--- /dev/null
+++ b/test/org/apache/ws/commons/om/StaxParserTest.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.ByteArrayInputStream;
+import java.util.Iterator;
+
+public class StaxParserTest extends AbstractTestCase {
+
+ XMLStreamReader parser1;
+ XMLStreamReader parser2;
+ XMLStreamReader parser3;
+ XMLStreamReader parser4;
+ String xmlDocument = "<purchase-order xmlns=\"http://openuri.org/easypo\">" +
+ "<customer>" +
+ " <name>Gladys Kravitz</name>" +
+ " <address>Anytown, PA</address>" +
+ " </customer>" +
+ " <date>2005-03-06T14:06:12.697+06:00</date>" +
+ "</purchase-order>";
+
+ public StaxParserTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ //make the parsers
+ //Parser 1 is a plain parser from the stax implementation
+ parser1 =
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes()));
+
+ //parser 2 is one of our parsers taken with cache. i.e. when the parser
+ //proceeds the object model will be built
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes())));
+ parser2 = builder.getDocumentElement().getXMLStreamReader();
+
+ //same as parser2 but this time the parser is not a caching parser. Once the
+ //parser proceeds, it's gone forever.
+ OMXMLParserWrapper builder2 = OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes())));
+ parser3 =
+ builder2.getDocumentElement().getXMLStreamReaderWithoutCaching();
+
+ //parser4 is another instance of our parser accessing the same stream as parser3.
+ // Note - The implementation returns a *new* instance but with reference to
+ //the same underlying stream!
+ parser4 = builder2.getDocumentElement().getXMLStreamReaderWithoutCaching();
+
+ }
+
+ public void testParserEventsWithCache() throws Exception {
+
+ //check the initial event
+ assertEquals(parser1.getEventType(), parser2.getEventType());
+
+ //check the other events
+ while (parser1.hasNext()) {
+
+ int parser1Event = parser1.next();
+ int parser2Event = parser2.next();
+ assertEquals(parser1Event, parser2Event);
+
+ }
+
+
+ }
+
+ public void testParserEventsWithoutCache() throws Exception {
+
+ assertEquals(parser1.getEventType(), parser3.getEventType());
+
+ while (parser1.hasNext()) {
+ int parser1Event = parser1.next();
+ int parser2Event = parser3.next();
+ assertEquals(parser1Event, parser2Event);
+ }
+
+
+ }
+
+ public void testParserEvents2WithCache() throws Exception {
+ while (parser1.hasNext()) {
+ int parser1Event = parser1.getEventType();
+ int parser2Event = parser2.getEventType();
+ parser1.next();
+ parser2.next();
+ assertEquals(parser1Event, parser2Event);
+ }
+
+
+ }
+
+
+ public void testParserBehaviornonCaching() throws Exception{
+
+ OMXMLParserWrapper builder2 = OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getOMFactory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes())));
+
+ OMElement documentElement = builder2.getDocumentElement();
+ XMLStreamReader originalParser =
+ documentElement.getXMLStreamReaderWithoutCaching();
+
+ //consume the parser. this should force the xml stream to be exhausted without
+ //building the tree
+ while(originalParser.hasNext()){
+ originalParser.next();
+ }
+
+ //try to find the children of the document element. This should produce an
+ //error since the underlying stream is fully consumed without building the object tree
+ Iterator childElements = documentElement.getChildElements();
+ try {
+ while (childElements.hasNext()) {
+ childElements.next();
+ fail("The stream should've been consumed by now!");
+ }
+ } catch (Exception e) {
+ //if we are here without failing, then we are successful
+ }
+ }
+
+
+ public void testParserBehaviorCaching() throws Exception{
+
+ OMXMLParserWrapper builder2 = OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes())));
+
+ OMElement documentElement = builder2.getDocumentElement();
+ XMLStreamReader originalParser =
+ documentElement.getXMLStreamReader();
+
+ //consume the parser. this should force the xml stream to be exhausted but the
+ //tree to be fully built
+ while(originalParser.hasNext()){
+ originalParser.next();
+ }
+
+ //try to find the children of the document element. This should *NOT* produce an
+ //error even when the underlying stream is fully consumed , the object tree is already complete
+ Iterator childElements = documentElement.getChildElements();
+ int count = 0;
+ try {
+ while (childElements.hasNext()) {
+ childElements.next();
+ count++;
+ }
+ } catch (Exception e) {
+ fail("The object tree needs to be built and traversing the children is to be a success!");
+ }
+
+ assertEquals("Number of elements need to be 2",count,2);
+ }
+
+
+ public void testParserBehaviorNonCaching2() throws Exception{
+
+ OMXMLParserWrapper builder2 = OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new ByteArrayInputStream(xmlDocument.getBytes())));
+
+ OMElement documentElement = builder2.getDocumentElement();
+
+ XMLStreamReader originalParser =
+ documentElement.getXMLStreamReaderWithoutCaching();
+
+ //consume the parser. this should force the xml stream to be exhausted without
+ //building the tree
+ while(originalParser.hasNext()){
+ originalParser.next();
+ }
+
+ //try to find the children of the document element. This should produce an
+ //error since the underlying stream is fully consumed without building the object tree
+ Iterator childElements = documentElement.getChildElements();
+ try {
+ XMLStreamWriter writer =
+ XMLOutputFactory.newInstance().
+ createXMLStreamWriter(System.out);
+ documentElement.serializeAndConsume(writer);
+ fail("Stream should be consumed by now");
+ }catch(XMLStreamException e){
+ //wea re cool
+ } catch (Exception e) {
+ fail("This should throw an XMLStreamException");
+ }
+ }
+
+}
+
diff --git a/test/org/apache/ws/commons/om/TestConstants.java b/test/org/apache/ws/commons/om/TestConstants.java
new file mode 100644
index 0000000..3943193
--- /dev/null
+++ b/test/org/apache/ws/commons/om/TestConstants.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om;
+
+/**
+ * All the various files
+ * created 03-Nov-2005 12:02:12
+ */
+
+public class TestConstants {
+ public static final String TEST_RESOURCES = "test-resources";
+ public static final String SOAP_DIR = "soap";
+ public static final String SOAPMESSAGE = "soapmessage.xml";
+ public static final String SOAP_SOAPMESSAGE = "soap/soapmessage.xml";
+ public static final String SOAP_SOAPMESSAGE1 = "soap/soapmessage1.xml";
+ public static final String SAMPLE1 = "soap/sample1.xml";
+ public static final String WHITESPACE_MESSAGE = "soap/whitespacedMessage.xml";
+ public static final String MINIMAL_MESSAGE = "soap/minimalMessage.xml";
+ public static final String REALLY_BIG_MESSAGE = "soap/reallyReallyBigMessage.xml";
+ public static final String EMPTY_BODY_MESSAGE = "soap/emtyBodymessage.xml";
+ public static final String BAD_WRONG_SOAP_NS = "badsoap/wrongSoapNs.xml";
+ public static final String BAD_TWO_HEADERS = "badsoap/twoheaders.xml";
+ public static final String BAD_TWO_BODY = "badsoap/twoBodymessage.xml";
+ public static final String BAD_ENVELOPE_MISSING = "badsoap/envelopeMissing.xml";
+ public static final String BAD_HEADER_BODY_WRONG_ORDER = "badsoap/haederBodyWrongOrder.xml";
+
+ private TestConstants() {
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/factory/OMLinkedListImplFactoryTest.java b/test/org/apache/ws/commons/om/factory/OMLinkedListImplFactoryTest.java
new file mode 100644
index 0000000..3bead0c
--- /dev/null
+++ b/test/org/apache/ws/commons/om/factory/OMLinkedListImplFactoryTest.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.factory;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMTestUtils;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+/**
+ * User: Eran Chinthaka (eran.chinthaka@gmail.com)
+ * Date: Feb 8, 2005
+ * Time: 11:06:09 AM
+ * All Rights Reserved.
+ */
+public class OMLinkedListImplFactoryTest extends AbstractTestCase {
+
+ private Log log = LogFactory.getLog(getClass());
+
+ public OMLinkedListImplFactoryTest(String testName) {
+ super(testName);
+ }
+
+ SOAPFactory omFactory;
+ OMNamespace namespace;
+ String nsUri = "http://www.apache.org/~chinthaka";
+ String nsPrefix = "myhome";
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ omFactory = OMAbstractFactory.getSOAP11Factory();
+ namespace = omFactory.createOMNamespace(nsUri, nsPrefix);
+ }
+
+ public void testCreateOMElementWithNoBuilder() {
+ OMElement omElement = omFactory.createOMElement("chinthaka",
+ namespace);
+ assertTrue(
+ "Programatically created OMElement should have done = true ",
+ omElement.isComplete());
+
+ }
+
+ public void testCreateOMElement() {
+ try {
+ OMXMLParserWrapper omBuilder = OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/whitespacedMessage.xml"));
+ OMElement documentElement = omBuilder.getDocumentElement();
+ OMElement child = omFactory.createOMElement("child",
+ namespace,
+ documentElement,
+ omBuilder);
+ assertTrue(
+ "OMElement with a builder should start with done = false ",
+ !child.isComplete());
+ assertTrue("This OMElement must have a builder ",
+ child.getBuilder() instanceof OMXMLParserWrapper);
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testCreateOMNamespace() {
+ assertTrue("OMNamespace uri not correct",
+ nsUri.equals(namespace.getName())); // here equalsIgnoreCase should not be used as case does matter
+ assertTrue("OMNamespace prefix not correct",
+ nsPrefix.equals(namespace.getPrefix())); // here equalsIgnoreCase should not be used as case does matter
+ }
+
+ public void testCreateText() {
+ OMElement omElement = omFactory.createOMElement("chinthaka",
+ namespace);
+ String text = "sampleText";
+ OMText omText = omFactory.createText(omElement, text);
+ assertTrue("Programatically created OMText should have done = true ",
+ omText.isComplete());
+ assertTrue(
+ "Programatically created OMText should have correct text value ",
+ text.equals(omText.getText()));
+
+ }
+
+ public void testCreateSOAPBody() {
+ try {
+ OMXMLParserWrapper omBuilder = OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/minimalMessage.xml"));
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) omBuilder.getDocumentElement();
+ SOAPBody soapBodyOne = omFactory.createSOAPBody(soapEnvelope);
+ assertTrue(
+ "Programatically created SOAPBody should have done = true ",
+ soapBodyOne.isComplete());
+ soapBodyOne.detach();
+ SOAPBody soapBodyTwo = omFactory.createSOAPBody(soapEnvelope,
+ omBuilder);
+ assertTrue(
+ "SOAPBody with a builder should start with done = false ",
+ !soapBodyTwo.isComplete());
+ assertTrue("This SOAPBody must have a builder ",
+ soapBodyTwo.getBuilder() instanceof OMXMLParserWrapper);
+
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testCreateSOAPEnvelope() {
+ try {
+ omFactory.createOMNamespace(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI,
+ SOAPConstants.SOAP_DEFAULT_NAMESPACE_PREFIX);
+ SOAPEnvelope soapEnvelopeTwo = omFactory.createSOAPEnvelope();
+ assertTrue(
+ "Programatically created SOAPEnvelope should have done = true ",
+ soapEnvelopeTwo.isComplete());
+ SOAPEnvelope soapEnvelope = omFactory.createSOAPEnvelope(
+ OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/minimalMessage.xml")));
+ assertTrue(
+ "SOAPEnvelope with a builder should start with done = false ",
+ !soapEnvelope.isComplete());
+ assertTrue("This SOAPEnvelope must have a builder ",
+ soapEnvelope.getBuilder() instanceof OMXMLParserWrapper);
+
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testCreateSOAPHeader() {
+ try {
+ OMXMLParserWrapper omBuilder = OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/minimalMessage.xml"));
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) omBuilder.getDocumentElement();
+ SOAPHeader soapHeader = omFactory.createSOAPHeader(soapEnvelope);
+ assertTrue(
+ "Programatically created SOAPHeader should have done = true ",
+ soapHeader.isComplete());
+ soapHeader.detach();
+ SOAPHeader soapHeaderTwo = omFactory.createSOAPHeader(soapEnvelope,
+ omBuilder);
+ assertTrue(
+ "SOAPHeader with a builder should start with done = false ",
+ !soapHeaderTwo.isComplete());
+ assertTrue("This SOAPHeader must have a builder ",
+ soapHeaderTwo.getBuilder() instanceof OMXMLParserWrapper);
+
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testCreateSOAPHeaderBlock() {
+ try {
+ OMXMLParserWrapper omBuilder = OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/soapmessage.xml"));
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) omBuilder.getDocumentElement();
+ SOAPHeader soapHeader = soapEnvelope.getHeader();
+ SOAPHeaderBlock soapHeaderBlock = omFactory.createSOAPHeaderBlock(
+ "soapHeaderBlockOne", namespace, soapHeader);
+ assertTrue(
+ "Programatically created SOAPHeaderBlock should have done = true ",
+ soapHeaderBlock.isComplete());
+ SOAPHeaderBlock soapHeaderBlockTwo = omFactory.createSOAPHeaderBlock(
+ "soapHeaderBlockOne", namespace, soapHeader, omBuilder);
+ assertTrue(
+ "SOAPHeaderBlock with a builder should start with done = false ",
+ !soapHeaderBlockTwo.isComplete());
+ assertTrue("This SOAPHeaderBlock must have a builder ",
+ soapHeaderBlockTwo.getBuilder() instanceof OMXMLParserWrapper);
+
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testCreateSOAPFault() {
+ try {
+ OMXMLParserWrapper omBuilder = OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/soapmessage.xml"));
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) omBuilder.getDocumentElement();
+ SOAPBody soapBody = soapEnvelope.getBody();
+ SOAPFault soapFault = omFactory.createSOAPFault(soapBody,
+ new Exception(" this is just a test "));
+ assertTrue(
+ "Programatically created SOAPFault should have done = true ",
+ soapFault.isComplete());
+ soapFault.detach();
+ SOAPFault soapFaultTwo = omFactory.createSOAPFault(soapBody,
+ omBuilder);
+ assertTrue(
+ "SOAPFault with a builder should start with done = false ",
+ !soapFaultTwo.isComplete());
+ assertTrue("This SOAPFault must have a builder ",
+ soapFaultTwo.getBuilder() instanceof OMXMLParserWrapper);
+
+
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/impl/OMBlankElementTest.java b/test/org/apache/ws/commons/om/impl/OMBlankElementTest.java
new file mode 100644
index 0000000..c14e4a8
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/OMBlankElementTest.java
@@ -0,0 +1,64 @@
+package org.apache.ws.commons.om.impl;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMException;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.StringWriter;
+
+public class OMBlankElementTest extends TestCase {
+
+ public OMBlankElementTest(String name) {
+ super(name);
+ }
+
+ public void testBlankOMElem() throws XMLStreamException {
+ try {
+ //We should not get anything as the return value here: the output of the serialization
+ String value = buildBlankOMElem();
+ assertNull(
+ "There's a serialized output for a blank XML element that cannot exist",
+ value);
+ } catch (OMException e) {
+ }
+ }
+
+ String buildBlankOMElem() throws XMLStreamException {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace namespace1 = factory.createOMNamespace("", "");
+ OMElement elem1 = factory.createOMElement("", namespace1);
+
+ StringWriter writer = new StringWriter();
+ elem1.build();
+ elem1.serialize(writer);
+ writer.flush();
+ return writer.toString();
+ }
+
+ public void testOMElemWithWhiteSpace() throws XMLStreamException {
+ try {
+ //We should not get anything as the return value here: the output of the serialization
+ String value = buildWithWhiteSpaceOMElem();
+ assertNull(
+ "There's a serialized output for a blank XML element that cannot exist",
+ value);
+ } catch (OMException e) {
+ }
+ }
+
+ String buildWithWhiteSpaceOMElem() throws XMLStreamException {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace namespace1 = factory.createOMNamespace(" ", "");
+ OMElement elem1 = factory.createOMElement(" ", namespace1);
+
+ StringWriter writer = new StringWriter();
+ elem1.build();
+ elem1.serialize(writer);
+ writer.flush();
+ return writer.toString();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/builder/StAXOMBuilderTest.java b/test/org/apache/ws/commons/om/impl/builder/StAXOMBuilderTest.java
new file mode 100644
index 0000000..cfa76ab
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/builder/StAXOMBuilderTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.builder;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import java.io.FileReader;
+import java.util.Iterator;
+
+public class StAXOMBuilderTest extends AbstractTestCase {
+ StAXOMBuilder stAXOMBuilder;
+ FileReader testFile;
+ private OMElement rootElement;
+
+ /**
+ * Constructor.
+ */
+ public StAXOMBuilderTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ testFile = new FileReader(getTestResourceFile("non_soap.xml"));
+ stAXOMBuilder =
+ OMXMLBuilderFactory.createStAXOMBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ testFile));
+ }
+
+ public void testGetRootElement() throws Exception {
+ rootElement = stAXOMBuilder.getDocumentElement();
+ assertTrue("Root element can not be null", rootElement != null);
+ assertTrue(" Name of the root element is wrong",
+ rootElement.getLocalName().equalsIgnoreCase("Root"));
+ // get the first OMElement child
+ OMNode omnode = rootElement.getFirstOMChild();
+ while (omnode instanceof OMText) {
+ omnode = omnode.getNextOMSibling();
+ }
+ Iterator children = ((OMElement) omnode).getChildren();
+ int childrenCount = 0;
+ while (children.hasNext()) {
+ OMNode node = (OMNode) children.next();
+ if (node instanceof OMElement)
+ childrenCount++;
+ }
+ assertTrue(childrenCount == 5);
+ }
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/om/impl/llom/OMDocumentSerilizationTest.java b/test/org/apache/ws/commons/om/impl/llom/OMDocumentSerilizationTest.java
new file mode 100644
index 0000000..94d858f
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/llom/OMDocumentSerilizationTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMOutputFormat;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.ByteArrayOutputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * This tests the serializeAndConsume method
+ */
+public class OMDocumentSerilizationTest extends TestCase {
+
+ private OMDocument document;
+ private String xmlDeclStart = "<?xml";
+ private String encoding = "encoding='UTF-8'";
+ private String encoding_UTF16 = "encoding='UTF-16'";
+ private String encoding2 = "encoding=\"UTF-8\"";
+ private String encoding2_UTF16 = "encoding=\"UTF-16\"";
+ private String version = "version='1.0'";
+ private String version_11 = "version='1.1'";
+ private String version2 = "version=\"1.0\"";
+ private String version2_11 = "version=\"1.1\"";
+
+ public void setUp() {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+
+ OMNamespace namespace = factory.createOMNamespace("http://testuri.org","test");
+ OMElement documentElement = factory.createOMElement("DocumentElement",namespace);
+
+ OMElement child1 = factory.createOMElement("Child1",namespace);
+ child1.setText("TestText");
+ documentElement.addChild(child1);
+
+ document = factory.createOMDocument();
+ document.setOMDocumentElement(documentElement);
+
+ }
+
+ public OMDocumentSerilizationTest(String name) {
+ super(name);
+ }
+
+
+ public void testXMLDecleration() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ document.serializeAndConsume(baos);
+
+ String xmlDocument = new String(baos.toByteArray());
+
+ assertTrue("XML Declaration missing",-1<xmlDocument.indexOf(xmlDeclStart));
+ }
+
+ public void testExcludeXMLDeclaration() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ OMOutputFormat format = new OMOutputFormat();
+ format.setIgnoreXMLDeclaration(true);
+ document.serializeAndConsume(baos, format);
+
+ String xmlDocument = new String(baos.toByteArray());
+
+ assertTrue(
+ "XML Declaration is included when serilizing without the declaration",
+ -1 == xmlDocument.indexOf(xmlDeclStart));
+ }
+
+ public void testCharsetEncoding() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ document.serializeAndConsume(baos);
+
+ String xmlDocument = new String(baos.toByteArray());
+
+ assertTrue("Charset declaration missing",-1 < xmlDocument.indexOf(encoding) ||
+ -1 < xmlDocument.indexOf(encoding.toLowerCase()) ||
+ -1 < xmlDocument.indexOf(encoding2.toLowerCase()) ||
+ -1 < xmlDocument.indexOf(encoding2));
+ }
+
+ public void testCharsetEncodingUTF_16() throws XMLStreamException, UnsupportedEncodingException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ OMOutputFormat format = new OMOutputFormat();
+ format.setCharSetEncoding("UTF-16");
+ document.serializeAndConsume(baos, format);
+
+ String xmlDocument = new String(baos.toByteArray(),"UTF-16");
+ assertTrue("Charset declaration missing",-1<xmlDocument.indexOf(encoding_UTF16) ||
+ -1<xmlDocument.indexOf(encoding2_UTF16));
+ }
+
+
+ public void testXMLVersion() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ document.serializeAndConsume(baos);
+
+ String xmlDocument = new String(baos.toByteArray());
+ assertTrue("Charset declaration missing",-1<xmlDocument.indexOf(version) ||
+ -1<xmlDocument.indexOf(version2));
+ }
+
+ public void testXMLVersion_11() throws XMLStreamException {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ document.setXMLVersion("1.1");
+ document.serializeAndConsume(baos);
+
+ String xmlDocument = new String(baos.toByteArray());
+ assertTrue("Charset declaration missing",-1<xmlDocument.indexOf(version_11) ||
+ -1<xmlDocument.indexOf(version2_11));
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/llom/OMOutputTest.java b/test/org/apache/ws/commons/om/impl/llom/OMOutputTest.java
new file mode 100644
index 0000000..df0894c
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/llom/OMOutputTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom;
+
+import org.apache.ws.commons.attachments.ByteArrayDataSource;
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMOutputFormat;
+
+import javax.activation.DataHandler;
+import java.io.File;
+import java.io.FileOutputStream;
+
+public class OMOutputTest extends AbstractTestCase {
+
+ /**
+ * @param testName
+ */
+ public OMOutputTest(String testName) {
+ super(testName);
+ }
+
+ String outFileName;
+
+ String outBase64FileName;
+
+ OMElement envelope;
+
+ File outMTOMFile;
+
+ File outBase64File;
+
+ /*
+ * @see TestCase#setUp()
+ */
+ protected void setUp() throws Exception {
+ super.setUp();
+ DataHandler dataHandler;
+
+ outFileName = "OMSerializeMTOMOut.txt";
+ outBase64FileName = "OMSerializeBase64Out.xml";
+ outMTOMFile = getTempOutputFile(outFileName);
+ outBase64File = getTempOutputFile(outBase64FileName);
+
+ OMNamespaceImpl soap = new OMNamespaceImpl(
+ "http://schemas.xmlsoap.org/soap/envelope/", "soap");
+ envelope = new OMElementImpl("Envelope", soap);
+ OMElement body = new OMElementImpl("Body", soap);
+
+ OMNamespaceImpl dataName = new OMNamespaceImpl(
+ "http://www.example.org/stuff", "m");
+ OMElement data = new OMElementImpl("data", dataName);
+
+ OMNamespaceImpl mime = new OMNamespaceImpl(
+ "http://www.w3.org/2003/06/xmlmime", "m");
+
+ OMElement text = new OMElementImpl("name", dataName);
+ OMAttribute cType1 = new OMAttributeImpl("contentType", mime,
+ "text/plain");
+ text.addAttribute(cType1);
+ byte[] byteArray = new byte[]{13, 56, 65, 32, 12, 12, 7, -3, -2, -1,
+ 98};
+ dataHandler = new DataHandler(new ByteArrayDataSource(byteArray));
+ OMTextImpl textData = new OMTextImpl(dataHandler, false);
+
+ envelope.addChild(body);
+ body.addChild(data);
+ data.addChild(text);
+ text.addChild(textData);
+ }
+
+ /*
+ * @see TestCase#tearDown()
+ */
+ protected void tearDown() throws Exception {
+ super.tearDown();
+ if (this.outMTOMFile.exists()) {
+ this.outMTOMFile.delete();
+ }
+ if (this.outBase64File.exists()) {
+ this.outBase64File.delete();
+ }
+ }
+
+ public void testComplete() throws Exception {
+ OMOutputFormat mtomOutputFormat = new OMOutputFormat();
+ mtomOutputFormat.setDoOptimize(true);
+ OMOutputFormat baseOutputFormat = new OMOutputFormat();
+ baseOutputFormat.setDoOptimize(false);
+
+ envelope.serializeAndConsume(new FileOutputStream(outBase64File), baseOutputFormat);
+ envelope.serializeAndConsume(new FileOutputStream(outMTOMFile), mtomOutputFormat);
+ }
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilderTest.java b/test/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilderTest.java
new file mode 100644
index 0000000..3fe795f
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/llom/mtom/MTOMStAXSOAPModelBuilderTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.llom.mtom;
+
+import org.apache.ws.commons.attachments.MIMEHelper;
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP12Constants;
+
+import javax.activation.DataHandler;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.Iterator;
+
+public class MTOMStAXSOAPModelBuilderTest extends AbstractTestCase {
+ MIMEHelper mimeHelper;
+
+ String inFileName;
+
+ OMXMLParserWrapper builder;
+
+ /**
+ * @param testName
+ */
+ public MTOMStAXSOAPModelBuilderTest(String testName) {
+ super(testName);
+ }
+
+ String contentTypeString = "multipart/Related; type=\"application/xop+xml\"; boundary=\"----=_AxIs2_Def_boundary_=42214532\"; start=\"SOAPPart\"";
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ inFileName = "mtom/MTOMBuilderTestIn.txt";
+ InputStream inStream = new FileInputStream(getTestResourceFile(inFileName));
+ mimeHelper = new MIMEHelper(inStream, contentTypeString);
+ XMLStreamReader reader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new BufferedReader(new InputStreamReader(mimeHelper
+ .getSOAPPartInputStream())));
+ builder = new MTOMStAXSOAPModelBuilder(reader, mimeHelper, SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI);
+ }
+
+ public void testCreateOMElement() throws Exception {
+ OMElement root = builder.getDocumentElement();
+// System.out.println(root.getLocalName() + " : "
+// + root.getNamespace().getName());
+ OMElement body = (OMElement) root.getFirstOMChild();
+// System.out.println(body.getLocalName() + " : "
+// + body.getNamespace().getName());
+
+ OMElement data = (OMElement) body.getFirstOMChild();
+// System.out.println(data.getLocalName() + " : "
+// + data.getNamespace().getName());
+ Iterator childIt = data.getChildren();
+ //while (childIt.hasNext()) {
+ OMElement child = (OMElement) childIt.next();
+ OMText blob = (OMText) child.getFirstOMChild();
+ /*
+ * Following is the procedure the user has to follow to read objects in
+ * OBBlob User has to know the object type & whether it is serializable.
+ * If it is not he has to use a Custom Defined DataSource to get the
+ * Object.
+ */
+ byte[] expectedObject = new byte[]{13, 56, 65, 32, 12, 12, 7, -3, -2,
+ -1, 98};
+ DataHandler actualDH;
+ actualDH = (DataHandler)blob.getDataHandler();
+ //ByteArrayInputStream object = (ByteArrayInputStream) actualDH
+ //.getContent();
+ //byte[] actualObject= null;
+ // object.read(actualObject,0,10);
+
+ // assertEquals("Object check", expectedObject[5],actualObject[5] );
+ }
+
+ public void testGetDataHandler() {
+ }
+
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/om/impl/serializer/ElementSerializerTest.java b/test/org/apache/ws/commons/om/impl/serializer/ElementSerializerTest.java
new file mode 100644
index 0000000..95fd306
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/serializer/ElementSerializerTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.serializer;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMNode;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+
+public class ElementSerializerTest extends AbstractTestCase {
+ private XMLStreamReader reader;
+ private XMLStreamWriter writer;
+ private OMXMLParserWrapper builder;
+ private File tempFile;
+
+ public ElementSerializerTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ reader =
+ XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile("soap/soapmessage.xml")));
+ tempFile = File.createTempFile("temp", "xml");
+ writer = XMLOutputFactory.newInstance().
+ createXMLStreamWriter(new FileOutputStream(tempFile));
+ builder =
+ OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(), reader);
+ }
+
+ public void testElementSerilization() throws Exception {
+ OMElement elt = builder.getDocumentElement();
+ elt.serialize(writer);
+
+ }
+
+ public void testElementSerilizationCacheOff() throws Exception {
+ OMElement elt = builder.getDocumentElement();
+ elt.serialize(writer);
+
+ }
+
+ public void testElementSerilizationChild() throws Exception {
+ OMElement elt = builder.getDocumentElement();
+ OMNode node = elt.getFirstOMChild().getNextOMSibling();
+ node.serialize(writer);
+
+ }
+
+ public void testElementSerilizationSOAPBodyCacheOff() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ OMNode node = env.getBody();
+ node.serialize(writer);
+ }
+
+ public void testElement() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ SOAPBody body = env.getBody();
+ body.serialize(writer);
+ }
+
+ public void testCompleteElement() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ env.serialize(writer);
+ }
+
+ public void testDualNamespaces1() throws Exception {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace ns1 = factory.createOMNamespace("bar", "x");
+ OMNamespace ns2 = factory.createOMNamespace("bar", "y");
+ OMElement root = factory.createOMElement("root", ns1);
+ OMElement elt11 = factory.createOMElement("foo1", ns1);
+ OMElement elt12 = factory.createOMElement("foo2", ns1);
+ OMElement elt21 = factory.createOMElement("yuck", ns2);
+ OMElement elt22 = factory.createOMElement("yuck", ns2);
+ elt11.addChild(elt21);
+ elt12.addChild(elt22);
+ root.addChild(elt11);
+ root.addChild(elt12);
+ root.serialize(writer);
+ }
+
+ public void testDualNamespaces2() throws Exception {
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace ns1 = factory.createOMNamespace("bar", "x");
+ OMElement root = factory.createOMElement("root", ns1);
+ OMNamespace ns2 = root.declareNamespace("bar", "y");
+ OMElement elt1 = factory.createOMElement("foo", ns1);
+ OMElement elt2 = factory.createOMElement("yuck", ns2);
+ OMText txt1 = factory.createText(elt2, "blah");
+ elt2.addChild(txt1);
+ elt1.addChild(elt2);
+ root.addChild(elt1);
+ root.serialize(writer);
+ }
+
+ protected void tearDown() throws Exception {
+ tempFile.delete();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/serializer/NoNamespaceSerializerTest.java b/test/org/apache/ws/commons/om/impl/serializer/NoNamespaceSerializerTest.java
new file mode 100644
index 0000000..aa67091
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/serializer/NoNamespaceSerializerTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.serializer;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.ByteArrayInputStream;
+import java.io.InputStreamReader;
+
+public class NoNamespaceSerializerTest extends TestCase {
+
+ private String xmlTextOne = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
+ "<soapenv:Body>\n" +
+ " <ns1:getBalance xmlns:ns1=\"http://localhost:8081/axis/services/BankPort/\">\n" +
+ " <accountNo href=\"#id0\"/>\n" +
+ " </ns1:getBalance>\n" +
+ " </soapenv:Body></soapenv:Envelope>";
+
+ private String xmlText2 = "<purchase-order xmlns=\"http://openuri.org/easypo\">\n" +
+ " <customer>\n" +
+ " <name>Gladys Kravitz</name>\n" +
+ " <address>Anytown, PA</address>\n" +
+ " </customer>\n" +
+ " <date>2005-03-06T14:06:12.697+06:00</date>\n" +
+ "</purchase-order>";
+
+ private String xmlTextTwo = "<soapenv:Envelope xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
+ "<soapenv:Body>\n" +
+ " <getBalance xmlns=\"http://localhost:8081/axis/services/BankPort/\">\n" +
+ " <accountNo href=\"#id0\"/>\n" +
+ " </getBalance>\n" +
+ " </soapenv:Body></soapenv:Envelope>";
+
+ private XMLStreamReader readerOne;
+ private XMLStreamReader readerTwo;
+ private XMLStreamWriter writer;
+
+ // private OMXMLParserWrapper builder;
+ // private File tempFile;
+
+ private OMXMLParserWrapper builderOne;
+ private OMXMLParserWrapper builderTwo;
+ // private File tempFile;
+
+
+
+ protected void setUp() throws Exception {
+ readerOne =
+ XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new InputStreamReader(
+ new ByteArrayInputStream(xmlTextOne.getBytes())));
+ readerTwo =
+ XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new InputStreamReader(
+ new ByteArrayInputStream(xmlTextTwo.getBytes())));
+ writer = XMLOutputFactory.newInstance().
+ createXMLStreamWriter(System.out);
+ builderOne =
+ OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(), readerOne);
+ builderTwo =
+ OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(), readerTwo);
+ }
+
+
+// public void testSerilizationWithCacheOff() throws Exception {
+// SOAPEnvelope env = (SOAPEnvelope) builderOne.getDocumentElement();
+// env.serializeAndConsume(writer, false);
+// writer.flush();
+//
+//
+// }
+//
+// public void testSerilizationWithCacheOn() throws Exception {
+// SOAPEnvelope env = (SOAPEnvelope) builderOne.getDocumentElement();
+// env.serializeAndConsume(writer, true);
+// writer.flush();
+// }
+
+
+ public void testSerilizationWithDefaultNamespaces() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builderTwo.getDocumentElement();
+ env.serialize(writer);
+ OMElement balanceElement = env.getBody().getFirstElement();
+ assertEquals("Deafualt namespace has not been set properly",
+ balanceElement.getNamespace().getName(),
+ "http://localhost:8081/axis/services/BankPort/");
+
+ OMElement accountNo = balanceElement.getFirstElement();
+ assertEquals(
+ "Deafualt namespace of children has not been set properly",
+ accountNo.getNamespace().getName(),
+ "http://localhost:8081/axis/services/BankPort/");
+
+ }
+
+ public void submitPurchaseOrderTest()
+ throws Exception {
+ SOAPFactory omFactory = OMAbstractFactory.getSOAP11Factory();
+ SOAPEnvelope env = omFactory.getDefaultEnvelope();
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXOMBuilder(
+ omFactory,
+ XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new InputStreamReader(
+ new ByteArrayInputStream(xmlText2.getBytes()))));
+ env.getBody().addChild(builder.getDocumentElement());
+
+ env.serialize(System.out);
+ }
+
+ public void testSerilizationWithCacheOn() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builderOne.getDocumentElement();
+ env.serialize(writer);
+ writer.flush();
+ }
+
+ public void testSerilizationWithCacheOff() throws Exception {
+ SOAPEnvelope env = (SOAPEnvelope) builderOne.getDocumentElement();
+ env.serialize(writer);
+ writer.flush();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/serializer/OMSerializerTest.java b/test/org/apache/ws/commons/om/impl/serializer/OMSerializerTest.java
new file mode 100644
index 0000000..b2d95ba
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/serializer/OMSerializerTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.serializer;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.om.impl.llom.serialize.StreamingOMSerializer;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import java.io.File;
+import java.io.FileReader;
+
+public class OMSerializerTest extends AbstractTestCase {
+ private XMLStreamReader reader;
+ private XMLStreamWriter writer;
+ private File tempFile;
+
+ public OMSerializerTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ reader =
+ XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile("soap/soapmessage.xml")));
+ tempFile = File.createTempFile("temp", "xml");
+// writer =
+// XMLOutputFactory.newInstance().
+// createXMLStreamWriter(new FileOutputStream(tempFile));
+ writer =
+ XMLOutputFactory.newInstance().
+ createXMLStreamWriter(System.out);
+ }
+
+ public void testRawSerializer() throws Exception {
+ StreamingOMSerializer serializer = new StreamingOMSerializer();
+ //serializer.setNamespacePrefixStack(new Stack());
+ serializer.serialize(reader, writer);
+ writer.flush();
+
+
+ }
+
+ public void testElementPullStream1() throws Exception {
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ reader);
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ StreamingOMSerializer serializer = new StreamingOMSerializer();
+ serializer.serialize(env.getXMLStreamReaderWithoutCaching(), writer);
+ writer.flush();
+ }
+
+ public void testElementPullStream1WithCacheOff() throws Exception {
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ reader);
+
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ env.serializeAndConsume(writer);
+ writer.flush();
+
+ //now we should not be able to serilaize anything ! this should throw
+ //an error
+ try {
+ env.serializeAndConsume(writer);
+ fail();
+ } catch (XMLStreamException e) {
+ assertTrue(true);
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testElementPullStream2() throws Exception {
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(),
+ reader);
+ SOAPEnvelope env = (SOAPEnvelope) builder.getDocumentElement();
+ SOAPBody body = env.getBody();
+ StreamingOMSerializer serializer = new StreamingOMSerializer();
+ serializer.serialize(body.getXMLStreamReaderWithoutCaching(),
+ writer);
+ writer.flush();
+ }
+
+ protected void tearDown() throws Exception {
+ tempFile.delete();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/serializer/PreserveEnvelopeTest.java b/test/org/apache/ws/commons/om/impl/serializer/PreserveEnvelopeTest.java
new file mode 100644
index 0000000..3c34d41
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/serializer/PreserveEnvelopeTest.java
@@ -0,0 +1,97 @@
+package org.apache.ws.commons.om.impl.serializer;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.custommonkey.xmlunit.XMLTestCase;
+
+import javax.xml.stream.XMLStreamException;
+import java.io.ByteArrayInputStream;
+
+ public class PreserveEnvelopeTest extends XMLTestCase{
+
+
+ private String originalXML = "<Assertion xmlns=\"urn:oasis:names:tc:SAML:1.0:assertion\" xmlns:saml=\"urn:oasis:names:tc:SAML:1.0:assertion\" xmlns:samlp=\"urn:oasis:names:tc:SAML:1.0:protocol\" AssertionID=\"ef98507718ea606c6ae1e89d2c0865ee\" IssueInstant=\"2006-01-03T15:09:35.164Z\" Issuer=\"C=US,O=National Center for Supercomputing Applications,CN=Hemapani Srinath Perera\" MajorVersion=\"1\" MinorVersion=\"1\"><Conditions NotBefore=\"2006-01-03T15:09:35.164Z\" NotOnOrAfter=\"2006-01-03T15:39:35.164Z\"><AudienceRestrictionCondition><Audience>http://www.extreme.indiana.edu/lead/TestCMD_Simple_Tue_Jan_03_10_09_27_EST_2006_142825</Audience></AudienceRestrictionCondition></Conditions><AuthorizationDecisionStatement Decision=\"Permit\" Resource=\"http://www.extreme.indiana.edu/lead/TestCMD_Simple_Tue_Jan_03_10_09_27_EST_2006_142825\"><Subject><NameIdentifier>/C=US/O=Indiana University/OU=Computer Science/CN=Hemapani Srinath Perera</NameIdentifier><SubjectConfirmation><ConfirmationMethod>urn:oasis:names:tc:SAML:1.0:cm:bearer</ConfirmationMethod></SubjectConfirmation></Subject><Action Namespace=\"http://www.extreme.indiana.edu/lead\">Run</Action></AuthorizationDecisionStatement><ds:Signature xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#\">\n" +
+ "<ds:SignedInfo>\n" +
+ "<ds:CanonicalizationMethod Algorithm=\"http://www.w3.org/2001/10/xml-exc-c14n#\"></ds:CanonicalizationMethod>\n" +
+ "<ds:SignatureMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#rsa-sha1\"></ds:SignatureMethod>\n" +
+ "<ds:Reference URI=\"#ef98507718ea606c6ae1e89d2c0865ee\">\n" +
+ "<ds:Transforms>\n" +
+ "<ds:Transform Algorithm=\"http://www.w3.org/2000/09/xmldsig#enveloped-signature\"></ds:Transform>\n" +
+ "<ds:Transform Algorithm=\"http://www.w3.org/2001/10/xml-exc-c14n#\"><ec:InclusiveNamespaces xmlns:ec=\"http://www.w3.org/2001/10/xml-exc-c14n#\" PrefixList=\"code ds kind rw saml samlp typens #default\"></ec:InclusiveNamespaces></ds:Transform>\n" +
+ "</ds:Transforms>\n" +
+ "<ds:DigestMethod Algorithm=\"http://www.w3.org/2000/09/xmldsig#sha1\"></ds:DigestMethod>\n" +
+ "<ds:DigestValue>0bqebD+zkADcbXleyxpFUySp7cY=</ds:DigestValue>\n" +
+ "</ds:Reference>\n" +
+ "</ds:SignedInfo>\n" +
+ "<ds:SignatureValue>\n" +
+ "HVZDR4InypCICJxbCSrZJsikcpSACZRTt5Ly2gfLBUpdVeq6koHAKo8WGrGHbZVzNFAmxj3i52jQ\n" +
+ "aYeO0J6LIA==\n" +
+ "</ds:SignatureValue>\n" +
+ "<ds:KeyInfo>\n" +
+ "<ds:X509Data>\n" +
+ "<ds:X509Certificate>\n" +
+ "MIIClDCCAXygAwIBAwICBEkwDQYJKoZIhvcNAQEEBQAwaTELMAkGA1UEBhMCVVMxODA2BgNVBAoT\n" +
+ "L05hdGlvbmFsIENlbnRlciBmb3IgU3VwZXJjb21wdXRpbmcgQXBwbGljYXRpb25zMSAwHgYDVQQD\n" +
+ "ExdIZW1hcGFuaSBTcmluYXRoIFBlcmVyYTAeFw0wNjAxMDMxNDM2MTFaFw0wNjAxMDQwMjQxMTFa\n" +
+ "MHkxCzAJBgNVBAYTAlVTMTgwNgYDVQQKEy9OYXRpb25hbCBDZW50ZXIgZm9yIFN1cGVyY29tcHV0\n" +
+ "aW5nIEFwcGxpY2F0aW9uczEgMB4GA1UEAxMXSGVtYXBhbmkgU3JpbmF0aCBQZXJlcmExDjAMBgNV\n" +
+ "BAMTBXByb3h5MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALyBo53oJTrVjs/RCFLJaMKektAqeNCi\n" +
+ "IAhEx+pE0BxL23WV8mhxUNDJevO7lkRuwuDWchbobq8S1WNRYrbOqRkCAwEAATANBgkqhkiG9w0B\n" +
+ "AQQFAAOCAQEAEZRsxz1izBa8SNw7x1nCttjTDnRM102CTad/uq3vihKmOauBo8lFqklT2xoFv+Nx\n" +
+ "WX1FXT5AAqedITtUn99zk3Sr5c/SgdO59NxSaWgqxTOd7koZUmz8Sta9IK7d1fDFhDie2W2EtUMk\n" +
+ "QX0Rr7KHReF6a0knQ+kGlhDuA2YN27CpNg+gBTq0+p1yaVA79qf2BVDYBklPG2N5tWn2GekHoUMs\n" +
+ "7nlU9WlUI0tRUKuGGdQ+2WLTW0w2UuqsJuHvDaquZRnTOjhdiRw5/Mg62LqkSwo99Dc3JiJusqoY\n" +
+ "16Unq8wp5gVJbj36UoVvqnVOyBltseIaU5bLS5LIrv11hXA6fg==\n" +
+ "</ds:X509Certificate>\n" +
+ "<ds:X509Certificate>\n" +
+ "MIIEVzCCAz+gAwIBAgICBEkwDQYJKoZIhvcNAQEEBQAwaTELMAkGA1UEBhMCVVMxODA2BgNVBAoT\n" +
+ "L05hdGlvbmFsIENlbnRlciBmb3IgU3VwZXJjb21wdXRpbmcgQXBwbGljYXRpb25zMSAwHgYDVQQD\n" +
+ "ExdDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNTEwMjUxOTMxMzRaFw0wNzEwMjUxOTMxMzRa\n" +
+ "MGkxCzAJBgNVBAYTAlVTMTgwNgYDVQQKEy9OYXRpb25hbCBDZW50ZXIgZm9yIFN1cGVyY29tcHV0\n" +
+ "aW5nIEFwcGxpY2F0aW9uczEgMB4GA1UEAxMXSGVtYXBhbmkgU3JpbmF0aCBQZXJlcmEwggEiMA0G\n" +
+ "CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC/pkVn4ZUEM5BjfocwiiQVF4ivFpJJ8u1m8vq0WNlc\n" +
+ "bw4rjMOet1YArC46fZ1Gg652A1dF92+8hHNeBa6chll5HRZkx5FLN7XEGY4EcHhXA6lHmjklpf8N\n" +
+ "Iy6/91ElOT1pVoLRpOeJ1TFT/nQxMBMJbMyhycrUV49M8oL3O/CYAm1YVQjCtdieK/ibFXzgP2iX\n" +
+ "R8oOrAX/Ogp+FilUkdrZlhhhzV/NdGdQrPQxxpWbXsLOgiyEU4W1BWSHHI1E1cs0KUoYvaboAYaq\n" +
+ "E+0WZlhqDxQy3SKOZVPYk9fJu9+qAb0gaDIgtN4FrZFYvTrlNMcrmyaC2ozr43nxwVMlq9dnAgMB\n" +
+ "AAGjggEHMIIBAzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIE8DAdBgNVHQ4EFgQU90FgTLg4k1yN3yJu\n" +
+ "d4TZIbxUGigwgZMGA1UdIwSBizCBiIAU8r6NqmFJES25W3IkKhjSwoXGmIGhbaRrMGkxCzAJBgNV\n" +
+ "BAYTAlVTMTgwNgYDVQQKEy9OYXRpb25hbCBDZW50ZXIgZm9yIFN1cGVyY29tcHV0aW5nIEFwcGxp\n" +
+ "Y2F0aW9uczEgMB4GA1UEAxMXQ2VydGlmaWNhdGlvbiBBdXRob3JpdHmCAQAwNAYDVR0fBC0wKzAp\n" +
+ "oCegJYYjaHR0cDovL2NhLm5jc2EudWl1Yy5lZHUvNGE2Y2Q4YjEucjAwDQYJKoZIhvcNAQEEBQAD\n" +
+ "ggEBAHnFMFeZTHjuq/juH3qw1jDrr4IuKnljuLHWSi8GuMt1mxOs/vR7rMg0OAs16gMJP3X2uSK5\n" +
+ "0miXqsbZ4AQuBJqo5Pm8UaSzeJlBle02SUvt2Fxhze9odLgoUXHp/1hKm9blHbp5cZqlbsmckk8y\n" +
+ "4xOPgNYh1G3oxdv2OcadmJBMlYwcBK+TkO8GbemqXqdFt6itGkkhLGQdspw9c1r38bXd9lhLbVR8\n" +
+ "7yif8ffqIgouVe/wj3NIjSbxgjff88Hz6CCuOWiafvfpgmrU906yOZqe6jBDBTKF5xmqyCNKKFAJ\n" +
+ "UbmPCX2vMKCpWrLU+MotR2HSbljslSUhfKCjHvFb/AA=\n" +
+ "</ds:X509Certificate>\n" +
+ "</ds:X509Data>\n" +
+ "</ds:KeyInfo></ds:Signature></Assertion>";
+
+
+
+ public void testOMNS() {
+ try {
+ StAXOMBuilder builder = new StAXOMBuilder(new ByteArrayInputStream(originalXML.getBytes()));
+ OMElement documentElement = builder.getDocumentElement();
+ //assertXMLEqual(originalXML, documentElement.toString());
+
+ String outstr = documentElement.toString();
+ System.out.println(outstr);
+ assertTrue(outstr.indexOf("xmlns:saml=") > 0);
+ assertTrue(outstr.indexOf("<Assertion") == 0);
+
+ } catch (XMLStreamException e) {
+ e.printStackTrace();
+
+ }
+ }
+
+
+
+ }
+
+
+
+
+
diff --git a/test/org/apache/ws/commons/om/impl/streamwrapper/OMStaxStreamingWrapperTest.java b/test/org/apache/ws/commons/om/impl/streamwrapper/OMStaxStreamingWrapperTest.java
new file mode 100644
index 0000000..aa61273
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/streamwrapper/OMStaxStreamingWrapperTest.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.streamwrapper;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.File;
+import java.io.FileReader;
+
+public class OMStaxStreamingWrapperTest extends AbstractTestCase {
+ private SOAPEnvelope envelope = null;
+ private File tempFile;
+ private XMLStreamReader parser;
+
+ public OMStaxStreamingWrapperTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ XMLStreamReader xmlStreamReader = XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile("soap/soapmessage1.xml")));
+ OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXSOAPModelBuilder(
+ OMAbstractFactory.getSOAP11Factory(), xmlStreamReader);
+ envelope = (SOAPEnvelope) builder.getDocumentElement();
+ tempFile = File.createTempFile("temp", "xml");
+
+ }
+
+
+ // public void testWrapperFullOM() throws Exception {
+ // assertNotNull(envelope);
+ // //this serializing will cause the OM to fully build!
+ // XMLStreamWriter writer = XMLOutputFactory.newInstance().createXMLStreamWriter(new FileOutputStream(tempFile));
+ // envelope.serializeAndConsume(writer,true);
+ // parser = envelope.getXMLStreamReader(false);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // }
+ //
+ // }
+
+ public void testWrapperHalfOM() throws Exception {
+ assertNotNull(envelope);
+ parser = envelope.getXMLStreamReaderWithoutCaching();
+ while (parser.hasNext()) {
+ int event = parser.next();
+ assertTrue(event > 0);
+ }
+ }
+
+ // public void testWrapperHalfOMWithCacheOff() throws Exception {
+ // assertNotNull(envelope);
+ // parser = envelope.getXMLStreamReader(true);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // }
+ // }
+ //
+ // public void testWrapperElementEventGenerationWithHalfOMWithCacheOff() throws XMLStreamException {
+ // assertNotNull(envelope);
+ // parser = envelope.getXMLStreamReader(true);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // if (event == XMLStreamConstants.START_ELEMENT) {
+ // checkStartElement(parser);
+ // } else if (event == XMLStreamConstants.CHARACTERS) {
+ // checkCharacters(parser);
+ // }
+ // }
+ //
+ //
+ // }
+ //
+ // public void testWrapperElementEventGenerationWithHalfOM() throws Exception {
+ // assertNotNull(envelope);
+ // parser = envelope.getXMLStreamReader(false);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // if (event == XMLStreamConstants.START_ELEMENT) {
+ // checkStartElement(parser);
+ // } else if (event == XMLStreamConstants.CHARACTERS) {
+ // checkCharacters(parser);
+ // }
+ // }
+ //
+ //
+ // }
+ //
+ // private void checkCharacters(XMLStreamReader wrapper) {
+ // assertFalse(wrapper.isStartElement());
+ // assertFalse(wrapper.isEndElement());
+ // assertFalse(wrapper.isWhiteSpace());
+ // assertFalse(wrapper.hasName());
+ // assertTrue(wrapper.isCharacters());
+ //
+ // assertNotNull(wrapper.getText());
+ // assertTrue(wrapper.getTextLength() > 0);
+ // }
+ //
+ // private void checkStartElement(XMLStreamReader wrapper) {
+ // assertTrue(wrapper.isStartElement());
+ // assertTrue(wrapper.hasName());
+ // assertFalse(wrapper.isEndElement());
+ // assertFalse(wrapper.isCharacters());
+ // assertFalse(wrapper.isWhiteSpace());
+ //
+ // //at the start element event these need to be supplied
+ // assertNotNull(wrapper.getLocalName());
+ // assertNotNull(wrapper.getName());
+ // assertNotNull(wrapper.getNamespaceURI());
+ // //prefix may be null
+ // wrapper.getPrefix();
+ //
+ // //todo add the other checks here
+ // int attribCount = wrapper.getAttributeCount();
+ // for (int i = 0; i < attribCount; i++) {
+ // assertNotNull(wrapper.getAttributeLocalName(i));
+ // assertNotNull(wrapper.getAttributeValue(i));
+ // assertNotNull(wrapper.getAttributeName(i));
+ // wrapper.getAttributePrefix(i);
+ // wrapper.getAttributeNamespace(i);
+ // //todo add the other checks here
+ // }
+ //
+ //
+ // }
+ //
+ // public void testWrapperElementEventGenerationWithHalfOMWithCacheOff() throws XMLStreamException {
+ // assertNotNull(envelope);
+ // parser = envelope.getXMLStreamReader(true);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // if (event == XMLStreamConstants.START_ELEMENT) {
+ // checkStartElement(parser);
+ // } else if (event == XMLStreamConstants.CHARACTERS) {
+ // checkCharacters(parser);
+ // }
+ // }
+ //
+ //
+ // }
+ //
+ // public void testWrapperElementEventGenerationWithHalfOM() throws Exception {
+ // assertNotNull(envelope);
+ // parser = envelope.getXMLStreamReader(false);
+ // while (parser.hasNext()) {
+ // int event = parser.next();
+ // assertTrue(event > 0);
+ // if (event == XMLStreamConstants.START_ELEMENT) {
+ // checkStartElement(parser);
+ // } else if (event == XMLStreamConstants.CHARACTERS) {
+ // checkCharacters(parser);
+ // }
+ // }
+ //
+ //
+ // }
+ //
+ // private void checkCharacters(XMLStreamReader wrapper) {
+ // assertFalse(wrapper.isStartElement());
+ // assertFalse(wrapper.isEndElement());
+ // assertFalse(wrapper.isWhiteSpace());
+ // assertFalse(wrapper.hasName());
+ // assertTrue(wrapper.isCharacters());
+ //
+ // assertNotNull(wrapper.getText());
+ // assertTrue(wrapper.getTextLength() > 0);
+ // }
+ //
+ // private void checkStartElement(XMLStreamReader wrapper) {
+ // assertTrue(wrapper.isStartElement());
+ // assertTrue(wrapper.hasName());
+ // assertFalse(wrapper.isEndElement());
+ // assertFalse(wrapper.isCharacters());
+ // assertFalse(wrapper.isWhiteSpace());
+ //
+ // //at the start element event these need to be supplied
+ // assertNotNull(wrapper.getLocalName());
+ // assertNotNull(wrapper.getName());
+ // assertNotNull(wrapper.getNamespaceURI());
+ // //prefix may be null
+ // wrapper.getPrefix();
+ //
+ // //todo add the other checks here
+ // int attribCount = wrapper.getAttributeCount();
+ // for (int i = 0; i < attribCount; i++) {
+ // assertNotNull(wrapper.getAttributeLocalName(i));
+ // assertNotNull(wrapper.getAttributeValue(i));
+ // assertNotNull(wrapper.getAttributeName(i));
+ // wrapper.getAttributePrefix(i);
+ // wrapper.getAttributeNamespace(i);
+ // //todo add the other checks here
+ // }
+ //
+ //
+ // }
+
+
+ protected void tearDown() throws Exception {
+ tempFile.delete();
+ }
+}
diff --git a/test/org/apache/ws/commons/om/impl/streamwrapper/OmStAXBuilderTest.java b/test/org/apache/ws/commons/om/impl/streamwrapper/OmStAXBuilderTest.java
new file mode 100644
index 0000000..75754df
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/streamwrapper/OmStAXBuilderTest.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.streamwrapper;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+
+public class OmStAXBuilderTest extends AbstractTestCase {
+ private SOAPFactory factory = null;
+ private OMXMLParserWrapper builder;
+ private File tempFile;
+
+ public OmStAXBuilderTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ factory = OMAbstractFactory.getSOAP11Factory();
+ XMLStreamReader reader = XMLInputFactory.newInstance().
+ createXMLStreamReader(
+ new FileReader(
+ getTestResourceFile("soap/soapmessage.xml")));
+ builder =
+ OMXMLBuilderFactory.createStAXSOAPModelBuilder(factory,
+ reader);
+ tempFile = File.createTempFile("temp", "xml");
+ }
+
+ public void testStaxBuilder() throws Exception {
+ SOAPEnvelope envelope = (SOAPEnvelope) builder.getDocumentElement();
+ assertNotNull(envelope);
+ envelope.serialize(new FileOutputStream(tempFile));
+
+
+ }
+
+ protected void tearDown() throws Exception {
+ tempFile.delete();
+ }
+
+
+}
diff --git a/test/org/apache/ws/commons/om/impl/traverse/OMChildrenWithSpecificAttributeIteratorTest.java b/test/org/apache/ws/commons/om/impl/traverse/OMChildrenWithSpecificAttributeIteratorTest.java
new file mode 100644
index 0000000..fbd7050
--- /dev/null
+++ b/test/org/apache/ws/commons/om/impl/traverse/OMChildrenWithSpecificAttributeIteratorTest.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.impl.traverse;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.impl.llom.traverse.OMChildrenWithSpecificAttributeIterator;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+public class OMChildrenWithSpecificAttributeIteratorTest extends TestCase {
+
+ public OMChildrenWithSpecificAttributeIteratorTest(String testName) {
+ super(testName);
+ }
+
+ public void testChildrenRetrievalWithDetaching() {
+
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace testNamespace = factory.createOMNamespace("http://test.ws.org", "test");
+ OMElement documentElement = getSampleDocumentElement(testNamespace);
+
+ Iterator childrenIter = new OMChildrenWithSpecificAttributeIterator(
+ documentElement.getFirstOMChild(), new QName(testNamespace.getName(), "myAttr",
+ testNamespace.getPrefix()), "Axis2", true);
+
+ int childCount = getChidrenCount(childrenIter);
+ assertEquals("Iterator must return 5 children with the given attribute", childCount, 5);
+
+ Iterator children = documentElement.getChildren();
+ childCount = getChidrenCount(children);
+ assertEquals("Iterator must return only one child, having detached the other children", childCount, 1);
+
+ }
+
+ public void testChildrenRetrievalWithNoDetaching() {
+
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ OMNamespace testNamespace = factory.createOMNamespace("http://test.ws.org", "test");
+ OMElement documentElement = getSampleDocumentElement(testNamespace);
+
+ Iterator childrenIter = new OMChildrenWithSpecificAttributeIterator(
+ documentElement.getFirstOMChild(), new QName(testNamespace.getName(), "myAttr",
+ testNamespace.getPrefix()), "Axis2", false);
+
+ int childCount = getChidrenCount(childrenIter);
+ assertEquals("Iterator must return 5 children with the given attribute", childCount, 5);
+
+ Iterator children = documentElement.getChildren();
+ childCount = getChidrenCount(children);
+ assertEquals("Iterator must return 6 children, having not detached the children", childCount, 6);
+
+ }
+
+ private OMElement getSampleDocumentElement(OMNamespace testNamespace){
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+
+ OMElement documentElement = factory.createOMElement("Employees", testNamespace);
+ documentElement.declareNamespace(testNamespace);
+
+ OMElement employee;
+ OMElement name;
+
+ for (int i = 0; i < 5; i++) {
+ employee = factory.createOMElement("Employee", testNamespace, documentElement);
+ name = factory.createOMElement("Name"+i, testNamespace);
+ employee.addAttribute("myAttr", "Axis2", testNamespace);
+ name.setText("Apache Developer");
+ employee.addChild(name);
+ }
+
+ //adding one more child with the given attr
+ employee = factory.createOMElement("Employee", testNamespace, documentElement);
+ name = factory.createOMElement("Name", testNamespace);
+ name.addAttribute("myAttr", "Un-Related Value", testNamespace);
+ name.setText("Apache Developer");
+ employee.addChild(name);
+
+ return documentElement;
+ }
+
+ private int getChidrenCount(Iterator childrenIter) {
+ int childCount = 0;
+ while (childrenIter.hasNext()) {
+ childrenIter.next();
+ childCount++;
+ }
+
+ return childCount;
+ }
+}
diff --git a/test/org/apache/ws/commons/om/infoset/XMLConformanceTest.java b/test/org/apache/ws/commons/om/infoset/XMLConformanceTest.java
new file mode 100644
index 0000000..91e979d
--- /dev/null
+++ b/test/org/apache/ws/commons/om/infoset/XMLConformanceTest.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.infoset;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import java.io.File;
+
+public class XMLConformanceTest extends TestCase {
+
+ public static Test suite() throws Exception {
+ TestSuite suite = new TestSuite();
+
+ File testSuiteDirectory = new File("test-resources/XMLSuite/xmlconf");
+ if (testSuiteDirectory.exists()) {
+ ProcessDir(testSuiteDirectory, suite);
+ }
+ return suite;
+ }
+
+ private static void ProcessDir(File dir, TestSuite suite) throws Exception {
+ if (dir.isDirectory()) {
+ //process all children
+ String[] children = dir.list();
+ for (int i = 0; i < children.length; i++) {
+ File child = (new File(dir, children[i]));
+ ProcessDir(child, suite);
+ }
+ } else {
+ //check if it's xml file
+ String absPath = dir.getAbsolutePath();
+ if (absPath.endsWith(".xml")) {
+ suite.addTest(new XMLConformanceUnit(absPath, "testSingleFileConformance"));
+ }
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/om/infoset/XMLConformanceUnit.java b/test/org/apache/ws/commons/om/infoset/XMLConformanceUnit.java
new file mode 100644
index 0000000..a1d9b08
--- /dev/null
+++ b/test/org/apache/ws/commons/om/infoset/XMLConformanceUnit.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.om.infoset;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMDocument;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.impl.llom.factory.OMXMLBuilderFactory;
+import org.custommonkey.xmlunit.Diff;
+import org.custommonkey.xmlunit.XMLTestCase;
+import org.w3c.dom.Document;
+import org.xml.sax.EntityResolver;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLInputFactory;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class XMLConformanceUnit extends XMLTestCase implements EntityResolver {
+
+ private String filePath;
+ private File directory;
+
+ public XMLConformanceUnit(String filePath, String testName) {
+ super(testName);
+ this.filePath = filePath;
+ this.directory = new File(filePath).getParentFile();
+ }
+
+ public void testSingleFileConformance()
+ throws Exception {
+ OMElement rootElement;
+
+ System.out.println("XML File:" + filePath);
+ XMLInputFactory factory = XMLInputFactory.newInstance();
+// factory.setProperty("report-cdata-event", Boolean.TRUE);
+ StAXOMBuilder staxOMBuilder = OMXMLBuilderFactory.
+ createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
+ factory.createXMLStreamReader(
+ new FileInputStream(filePath)));
+ rootElement = staxOMBuilder.getDocumentElement();
+
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ ((OMDocument)rootElement.getParent()).serialize(baos);
+
+ InputSource resultXML = new InputSource(new InputStreamReader(
+ new ByteArrayInputStream(baos.toByteArray())));
+
+ Document dom1 = newDocument(new InputSource(new FileReader(filePath)));
+ Document dom2 = newDocument(resultXML);
+
+ Diff diff = compareXML(dom1, dom2);
+ assertXMLEqual(diff, true);
+ }
+
+ /**
+ * Method newDocument
+ *
+ * @param in
+ * @return
+ * @throws javax.xml.parsers.ParserConfigurationException
+ *
+ * @throws org.xml.sax.SAXException
+ * @throws java.io.IOException
+ */
+ public Document newDocument(InputSource in)
+ throws ParserConfigurationException, SAXException, IOException {
+ DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+ dbf.setNamespaceAware(true);
+ DocumentBuilder db = dbf.newDocumentBuilder();
+ db.setEntityResolver(this);
+ return db.parse(in);
+ }
+
+ public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
+ File f = new File(directory, systemId.substring(systemId.lastIndexOf('/')));
+ return new InputSource(new FileInputStream(f));
+ }
+
+ public String getName() {
+ String name = filePath;
+ if(name.lastIndexOf("xmlconf")!=-1)
+ name = name.substring(name.lastIndexOf("xmlconf"));
+ return name.replace('\\','/');
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPBodyTest.java b/test/org/apache/ws/commons/soap/SOAPBodyTest.java
new file mode 100644
index 0000000..823c636
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPBodyTest.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMException;
+
+public class SOAPBodyTest extends SOAPBodyTestCase {
+
+ public SOAPBodyTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP 1.1 Body Test (Programaticaly created)----------------------------------------------------------------------------------
+ public void testSOAP11AddFault1() {
+ soap11Body.addFault(new Exception("This an exception for testing"));
+ assertTrue(
+ "SOAP 1.1 Body Test:- After calling addFault method, SOAP body has no fault",
+ soap11Body.hasFault());
+
+ }
+
+ public void testSOAP11addFault2() {
+ soap11Body.addFault(soap11Factory.createSOAPFault(soap11Body));
+ assertTrue(
+ "SOAP 1.1 Body Test:- After calling addFault method, SOAP body has no fault",
+ soap11Body.hasFault());
+
+
+ }
+
+ public void testSOAP11HasFault() {
+ assertFalse(
+ "SOAP 1.1 Body Test:- After creating a soap body it has a fault",
+ soap11Body.hasFault());
+ soap11Body.addFault(new Exception("This an exception for testing"));
+ assertTrue(
+ "SOAP 1.1 Body Test:- After calling addFault method, hasFault method returns false",
+ soap11Body.hasFault());
+ }
+
+ public void testSOAP11GetFault() {
+ assertTrue(
+ "SOAP 1.1 Body Test:- After creating a soap body it has a fault",
+ soap11Body.getFault() == null);
+ soap11Body.addFault(new Exception("This an exception for testing"));
+ assertFalse(
+ "SOAP 1.1 Body Test:- After calling addFault method, getFault method returns null",
+ soap11Body.getFault() == null);
+ }
+
+ //SOAP 1.2 Body Test (Programaticaly Created)----------------------------------------------------------------------------------
+ public void testSOAP12AddFault1() {
+ soap12Body.addFault(new Exception("This an exception for testing"));
+ assertTrue(
+ "SOAP 1.2 Body Test:- After calling addFault method, SOAP body has no fault",
+ soap12Body.hasFault());
+
+ }
+
+ public void testSOAP12AddFault2() {
+ soap12Body.addFault(soap12Factory.createSOAPFault(soap12Body));
+ assertTrue(
+ "SOAP 1.2 Body Test:- After calling addFault method, SOAP body has no fault",
+ soap12Body.hasFault());
+ }
+
+ public void testSOAP12HasFault() {
+ assertFalse(
+ "SOAP 1.2 Body Test:- After creating a soap body it has a fault",
+ soap12Body.hasFault());
+ soap12Body.addFault(new Exception("This an exception for testing"));
+ assertTrue(
+ "SOAP 1.2 Body Test:- After calling addFault method, hasFault method returns false",
+ soap12Body.hasFault());
+ }
+
+ public void testSOAP12GetFault() {
+ assertTrue(
+ "SOAP 1.2 Body Test:- After creating a soap body it has a fault",
+ soap12Body.getFault() == null);
+ soap12Body.addFault(new Exception("This an exception for testing"));
+ assertFalse(
+ "SOAP 1.2 Body Test:- After calling addFault method, getFault method returns null",
+ soap12Body.getFault() == null);
+ }
+
+ //SOAP 1.1 Body Test (With Parser)-------------------------------------------------------------------------------------------
+ public void testSOAP11HasFaultWithParser() {
+ assertTrue(
+ "SOAP 1.1 Body Test With parser :- hasFault method returns false",
+ soap11BodyWithParser.hasFault());
+ }
+
+ public void testSOAP11GetFaultWithParser() {
+ assertFalse(
+ "SOAP 1.1 Body Test With parser :- getFault method returns null",
+ soap11BodyWithParser.getFault() == null);
+ assertTrue(
+ "SOAP 1.1 Body Test With parser : - SOAP fault name mismatch",
+ soap11BodyWithParser.getFault().getLocalName().equals(
+ SOAPConstants.SOAPFAULT_LOCAL_NAME));
+ }
+
+ //SOAP 1.2 Body Test (With Parser)-------------------------------------------------------------------------------------------------
+ public void testSOAP12HasFaultWithParser() {
+ assertTrue(
+ "SOAP 1.2 Body Test With parser :- hasFault method returns false",
+ soap12BodyWithParser.hasFault());
+ }
+
+ public void testSOAP12GetFaultWithParser() {
+ assertFalse(
+ "SOAP 1.2 Body Test With parser :- getFault method returns null",
+ soap12BodyWithParser.getFault() == null);
+ assertTrue(
+ "SOAP 1.2 Body Test With parser : - SOAP fault name mismatch",
+ soap12BodyWithParser.getFault().getLocalName().equals(
+ SOAPConstants.SOAPFAULT_LOCAL_NAME));
+ }
+
+ public void testSOAPBodyDetachment(){
+ try {
+ soap11Body.detach();
+ fail("Detachment of SOAP Body is not allowed !!");
+ } catch (OMException e) {
+ assertTrue(true);
+ }
+
+ try {
+ soap12Body.detach();
+ fail("Detachment of SOAP Body is not allowed !!");
+ } catch (OMException e) {
+ assertTrue(true);
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPBodyTestCase.java b/test/org/apache/ws/commons/soap/SOAPBodyTestCase.java
new file mode 100644
index 0000000..a8771fc
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPBodyTestCase.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPBodyTestCase extends SOAPTestCase {
+ protected SOAPBody soap11Body;
+ protected SOAPBody soap12Body;
+
+ protected SOAPBody soap11BodyWithParser;
+ protected SOAPBody soap12BodyWithParser;
+
+ public SOAPBodyTestCase(String testName) {
+ super(testName);
+
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11Body = soap11Factory.createSOAPBody(soap11Envelope);
+ soap12Body = soap12Factory.createSOAPBody(soap12Envelope);
+
+ soap11BodyWithParser = soap11EnvelopeWithParser.getBody();
+ soap12BodyWithParser = soap12EnvelopeWithParser.getBody();
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPEnvelopeTest.java b/test/org/apache/ws/commons/soap/SOAPEnvelopeTest.java
new file mode 100644
index 0000000..38cb408
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPEnvelopeTest.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+
+public class SOAPEnvelopeTest extends SOAPTestCase {
+ protected SOAPEnvelope soap11Envelope;
+ protected SOAPEnvelope soap12Envelope;
+
+ public SOAPEnvelopeTest(String testName) {
+ super(testName);
+ soap11Envelope = soap11Factory.getDefaultEnvelope();
+ soap12Envelope = soap12Factory.getDefaultEnvelope();
+ }
+
+ //SOAP 1.1 Envelope Test (Programaticaly Created)-----------------------------------------------
+ public void testSOAP11GetHeader() {
+ SOAPHeader header = soap11Envelope.getHeader();
+ assertTrue("SOAP 1.1 Header Test : - Header local name mismatch",
+ header.getLocalName().equals(SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.1 Header Test : - Header namespace mismatch",
+ header.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ public void testSOAP11GetBody() {
+ SOAPBody body = soap11Envelope.getBody();
+ assertTrue("SOAP 1.1 Body Test : - Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.1 Body Test : - Body namespace mismatch",
+ body.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ //SOAP 1.2 Envelope Test (Programaticaly Created)-------------------------------------------------
+ public void testSOAP12GetHeader() {
+ SOAPHeader header = soap12Envelope.getHeader();
+ assertTrue("SOAP 1.2 Header Test : - Header local name mismatch",
+ header.getLocalName().equals(SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.2 Header Test : - Header namespace mismatch",
+ header.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ public void testSOAP12GetBody() {
+ SOAPBody body = soap12Envelope.getBody();
+ assertTrue("SOAP 1.2 Body Test : - Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.2 Body Test : - Body namespace mismatch",
+ body.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ //SOAP 1.1 Envelope Test (With Parser)-----------------------------------------------------------------
+ public void testSOAP11GetHeaderWithParser() {
+ SOAPHeader header = soap11EnvelopeWithParser.getHeader();
+ assertTrue("SOAP 1.1 Header Test : - Header local name mismatch",
+ header.getLocalName().equals(SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.1 Header Test : - Header namespace mismatch",
+ header.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ public void testSOAP11GetBodyWithParser() {
+ SOAPBody body = soap11EnvelopeWithParser.getBody();
+ assertTrue("SOAP 1.1 Body Test : - Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.1 Body Test : - Body namespace mismatch",
+ body.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ //SOAP 1.2 Envelope Test (With Parser)--------------------------------------------------------------------
+ public void testSOAP12GetHeaderWithParser() {
+ SOAPHeader header = soap12EnvelopeWithParser.getHeader();
+ assertTrue("SOAP 1.2 Header Test : - Header local name mismatch",
+ header.getLocalName().equals(SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.2 Header Test : - Header namespace mismatch",
+ header.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+
+ public void testSOAP12GetBodyWithParser() {
+ SOAPBody body = soap12EnvelopeWithParser.getBody();
+ assertTrue("SOAP 1.2 Body Test : - Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.2 Body Test : - Body namespace mismatch",
+ body.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultCodeTest.java b/test/org/apache/ws/commons/soap/SOAPFaultCodeTest.java
new file mode 100644
index 0000000..681c9c5
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultCodeTest.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+
+public class SOAPFaultCodeTest extends SOAPFaultCodeTestCase {
+
+ public SOAPFaultCodeTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP 1.1 Fault Code Test (Programaticaly Created)
+ public void testSOAP11SetValue() {
+ soap11FaultCode.setValue(
+ soap11Factory.createSOAPFaultValue(soap11FaultCode));
+ assertFalse(
+ "SOAP 1.1 Fault Code Test :- After calling setValue method, getValue method returns null",
+ soap11FaultCode.getValue() == null);
+ try {
+ soap11FaultCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultCode));
+ fail("SOAP12FaultValue should not be inserted to SOAP11FaultCode");
+ } catch (SOAPProcessingException e) {
+ assertTrue(true);
+ }
+
+ }
+
+ public void testSOAP11GetValue() {
+ assertTrue(
+ "SOAP 1.1 Fault Code Test :- After creating soapfaultcode, it has a value",
+ soap11FaultCode.getValue() == null);
+ soap11FaultCode.setValue(
+ soap11Factory.createSOAPFaultValue(soap11FaultCode));
+ assertFalse(
+ "SOAP 1.1 Fault Code Test :- After calling setValue method, getValue method returns null",
+ soap11FaultCode.getValue() == null);
+ }
+
+ //SOAP 1.2 Fault Code Test (Programaticaly Created)
+ public void testSOAP12SetValue() {
+ soap12FaultCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultCode));
+ assertFalse(
+ "SOAP 1.2 Fault Code Test :- After calling setValue method, getValue method returns null",
+ soap12FaultCode.getValue() == null);
+ try {
+ soap12FaultCode.setValue(
+ soap11Factory.createSOAPFaultValue(soap11FaultCode));
+ fail("SOAP11FaultValue should not be inserted to SOAP12FaultCode");
+ } catch (SOAPProcessingException e) {
+ assertTrue(true);
+ }
+
+ try {
+ soap12FaultCode.setValue(
+ soap12Factory.createSOAPFaultValue(
+ soap12Factory.createSOAPFaultSubCode(
+ soap12FaultCode)));
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.2 Fault Code Test :- When calling setValue method, parent of value element mismatch");
+ }
+ }
+
+ public void testSOAP12GetValue() {
+ assertTrue(
+ "SOAP 1.2 Fault Code Test :- After creating soapfaultcode, it has a value",
+ soap12FaultCode.getValue() == null);
+ soap12FaultCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultCode));
+ assertFalse(
+ "SOAP 1.2 Fault Code Test :- After calling setValue method, getValue method returns null",
+ soap12FaultCode.getValue() == null);
+ }
+
+ public void testSOAP12SetSubCode() {
+ soap12FaultCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultCode));
+ assertFalse(
+ "SOAP 1.2 Fault Code Test :- After calling setSubCode method, getSubCode method returns null",
+ soap12FaultCode.getSubCode() == null);
+ try {
+ soap12FaultCode.setSubCode(
+ soap11Factory.createSOAPFaultSubCode(soap11FaultCode));
+ fail(
+ "SOAP11FaultSubCode should not be inserted to SOAP12FaultCode");
+ } catch (SOAPProcessingException e) {
+ assertTrue(true);
+ }
+
+ try {
+ soap12FaultCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(
+ soap12Factory.createSOAPFaultSubCode(
+ soap12FaultCode)));
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.2 Fault Code Test :- When calling setSubCode method, parent of subcode element mismatch");
+ }
+ }
+
+ public void testSOAP12GetSubCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Code Test :- After creating soapfaultcode, it has a subcode",
+ soap12FaultCode.getSubCode() == null);
+ soap12FaultCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultCode));
+ assertFalse(
+ "SOAP 1.2 Fault Code Test :- After calling setSubCode method, getSubCode method returns null",
+ soap12FaultCode.getSubCode() == null);
+ }
+
+ //SOAP 1.1 Fault Code Test (With Parser)
+ public void testSOAP11GetValueWithParser() {
+ assertFalse(
+ "SOAP 1.1 Fault Code Test with parser : - getValue method returns null",
+ soap11FaultCodeWithParser.getValue() == null);
+ assertTrue(
+ "SOAP 1.1 Fault Code Test with parser : - Value local name mismatch",
+ soap11FaultCodeWithParser.getValue().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME));
+ }
+
+ //SOAP 1.2 Fault Code Test (With Parser)
+ public void testSOAP12GetValueWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Code Test with parser : - getValue method returns null",
+ soap12FaultCodeWithParser.getValue() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Code Test with parser : - Value local name mismatch",
+ soap12FaultCodeWithParser.getValue().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME));
+ }
+
+ public void testSOAP12GetSubCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Code Test with parser :- getSubCode method returns null",
+ soap12FaultCodeWithParser.getSubCode() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Code Test with parser : - subcode local name mismatch",
+ soap12FaultCodeWithParser.getSubCode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultCodeTestCase.java b/test/org/apache/ws/commons/soap/SOAPFaultCodeTestCase.java
new file mode 100644
index 0000000..270f65d
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultCodeTestCase.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultCodeTestCase extends SOAPFaultTestCase {
+
+ protected SOAPFaultCode soap11FaultCode;
+ protected SOAPFaultCode soap12FaultCode;
+
+ protected SOAPFaultCode soap11FaultCodeWithParser;
+ protected SOAPFaultCode soap12FaultCodeWithParser;
+
+ public SOAPFaultCodeTestCase(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ soap11FaultCode = soap11Factory.createSOAPFaultCode(soap11Fault);
+ soap12FaultCode = soap12Factory.createSOAPFaultCode(soap12Fault);
+
+ soap11FaultCodeWithParser = soap11FaultWithParser.getCode();
+ soap12FaultCodeWithParser = soap12FaultWithParser.getCode();
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultDetailTest.java b/test/org/apache/ws/commons/soap/SOAPFaultDetailTest.java
new file mode 100644
index 0000000..75b0d7f
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultDetailTest.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMText;
+
+import java.util.Iterator;
+
+public class SOAPFaultDetailTest extends SOAPFaultTestCase {
+ protected SOAPFaultDetail soap11FaultDetail;
+ protected SOAPFaultDetail soap12FaultDetail;
+ protected SOAPFaultDetail soap11FaultDetailWithParser;
+ protected SOAPFaultDetail soap12FaultDetailWithParser;
+ protected OMNamespace omNamespace;
+
+ public SOAPFaultDetailTest(String testName) {
+ super(testName);
+ omNamespace =
+ omFactory.createOMNamespace("http://www.test.org", "test");
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultDetail = soap11Factory.createSOAPFaultDetail(soap11Fault);
+ soap12FaultDetail = soap12Factory.createSOAPFaultDetail(soap12Fault);
+ soap11FaultDetailWithParser = soap11FaultWithParser.getDetail();
+ soap12FaultDetailWithParser = soap12FaultWithParser.getDetail();
+ }
+
+ //SOAP 1.1 Fault Detail Test (Programaticaly Created)
+ public void testSOAP11AddDetailEntry() {
+ soap11FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry1", omNamespace));
+ soap11FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry2", omNamespace));
+ Iterator iterator = soap11FaultDetail.getAllDetailEntries();
+ OMElement detailEntry1 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns empty iterator",
+ detailEntry1 == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry1 local name mismatch",
+ detailEntry1.getLocalName().equals("DetailEntry1"));
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry1 namespace uri mismatch",
+ detailEntry1.getNamespace().getName().equals(
+ "http://www.test.org"));
+ OMElement detailEntry2 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns an iterator with only one object",
+ detailEntry2 == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry2 local name mismatch",
+ detailEntry2.getLocalName().equals("DetailEntry2"));
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry2 namespace uri mismatch",
+ detailEntry2.getNamespace().getName().equals(
+ "http://www.test.org"));
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns an iterator with three objects",
+ iterator.next() == null);
+ }
+
+ public void testSOAP11GetAllDetailEntries() {
+ Iterator iterator = soap11FaultDetail.getAllDetailEntries();
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - After creating SOAP11FaultDetail element, it has DetailEntries",
+ iterator.next() == null);
+ soap11FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry", omNamespace));
+ iterator = soap11FaultDetail.getAllDetailEntries();
+ OMElement detailEntry = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test : - After calling addDetailEntry method, getAllDetailEntries method returns empty iterator",
+ detailEntry == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry local name mismatch",
+ detailEntry.getLocalName().equals("DetailEntry"));
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - detailEntry namespace uri mismatch",
+ detailEntry.getNamespace().getName().equals(
+ "http://www.test.org"));
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test : - After calling addDetailEntry method once, getAllDetailEntries method returns an iterator with two objects",
+ iterator.next() == null);
+ }
+
+ //SOAP 1.2 Fault Detail Test (Programaticaly Created)
+ public void testSOAP12AddDetailEntry() {
+ soap12FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry1", omNamespace));
+ soap12FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry2", omNamespace));
+ Iterator iterator = soap12FaultDetail.getAllDetailEntries();
+ OMElement detailEntry1 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns empty iterator",
+ detailEntry1 == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry1 local name mismatch",
+ detailEntry1.getLocalName().equals("DetailEntry1"));
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry1 namespace uri mismatch",
+ detailEntry1.getNamespace().getName().equals(
+ "http://www.test.org"));
+ OMElement detailEntry2 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns an iterator with only one object",
+ detailEntry2 == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry2 local name mismatch",
+ detailEntry2.getLocalName().equals("DetailEntry2"));
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry2 namespace uri mismatch",
+ detailEntry2.getNamespace().getName().equals(
+ "http://www.test.org"));
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - After calling addDetailEntry method twice, getAllDetailEntries method returns an iterator with three objects",
+ iterator.next() == null);
+ }
+
+ public void testSOAP12GetAllDetailEntries() {
+ Iterator iterator = soap12FaultDetail.getAllDetailEntries();
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - After creating SOAP11FaultDetail element, it has DetailEntries",
+ iterator.next() == null);
+ soap12FaultDetail.addDetailEntry(
+ omFactory.createOMElement("DetailEntry", omNamespace));
+ iterator = soap12FaultDetail.getAllDetailEntries();
+ OMElement detailEntry = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test : - After calling addDetailEntry method, getAllDetailEntries method returns empty iterator",
+ detailEntry == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry local name mismatch",
+ detailEntry.getLocalName().equals("DetailEntry"));
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - detailEntry namespace uri mismatch",
+ detailEntry.getNamespace().getName().equals(
+ "http://www.test.org"));
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test : - After calling addDetailEntry method once, getAllDetailEntries method returns an iterator with two objects",
+ iterator.next() == null);
+ }
+
+ //SOAP 1.1 Fault Detail Test (With Parser)
+ public void testSOAP11GetAllDetailEntriesWithParser() {
+ Iterator iterator = soap11FaultDetailWithParser.getAllDetailEntries();
+ OMText textEntry = (OMText) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test With Parser : - getAllDetailEntries method returns empty iterator",
+ textEntry == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test With Parser : - text value mismatch",
+ textEntry.getText().trim().equals("Details of error"));
+ OMElement detailEntry1 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator without detail entries",
+ detailEntry1 == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test With Parser : - detailEntry1 localname mismatch",
+ detailEntry1.getLocalName().equals("MaxTime"));
+ iterator.next();
+ OMElement detailEntry2 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator with only one detail entries",
+ detailEntry2 == null);
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test With Parser : - detailEntry2 localname mismatch",
+ detailEntry2.getLocalName().equals("AveTime"));
+ iterator.next();
+ assertTrue(
+ "SOAP 1.1 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator with more than two detail entries",
+ iterator.next() == null);
+ }
+
+ //SOAP 1.2 Fault Detail Test (With Parser)
+ public void testSOAP12GetAllDetailEntriesWithParser() {
+ Iterator iterator = soap12FaultDetailWithParser.getAllDetailEntries();
+ OMText textEntry = (OMText) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test With Parser : - getAllDetailEntries method returns empty iterator",
+ textEntry == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test With Parser : - text value mismatch",
+ textEntry.getText().trim().equals("Details of error"));
+ OMElement detailEntry1 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator without detail entries",
+ detailEntry1 == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test With Parser : - detailEntry1 localname mismatch",
+ detailEntry1.getLocalName().equals("MaxTime"));
+ iterator.next();
+ OMElement detailEntry2 = (OMElement) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator with only one detail entries",
+ detailEntry2 == null);
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test With Parser : - detailEntry2 localname mismatch",
+ detailEntry2.getLocalName().equals("AveTime"));
+ iterator.next();
+ assertTrue(
+ "SOAP 1.2 Fault Detail Test With Parser : - getAllDetailEntries method returns an itrator with more than two detail entries",
+ iterator.next() == null);
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultNodeTest.java b/test/org/apache/ws/commons/soap/SOAPFaultNodeTest.java
new file mode 100644
index 0000000..b8d6420
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultNodeTest.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultNodeTest extends SOAPFaultTestCase {
+ protected SOAPFaultNode soap11FaultNode;
+ protected SOAPFaultNode soap12FaultNode;
+ protected SOAPFaultNode soap12FaultNodeWithParser;
+
+ public SOAPFaultNodeTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultNode = soap11Factory.createSOAPFaultNode(soap11Fault);
+ soap12FaultNode = soap12Factory.createSOAPFaultNode(soap12Fault);
+ soap12FaultNodeWithParser = soap12FaultWithParser.getNode();
+ }
+
+ //SOAP 1.1 Fault Node Test (Programaticaly Created)
+ public void testSOAP11SetNodeValue() {
+ soap11FaultNode.setNodeValue("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Node Test : - After calling setNodeValue method, getNodeValue method returns incorrect value",
+ soap11FaultNode.getNodeValue().equals("This is only a test"));
+ }
+
+ public void testSOAP11GetNodeValue() {
+ assertTrue(
+ "SOAP 1.1 Fault Node Test : - After creating SOAPFaultNode, it has a value",
+ soap11FaultNode.getNodeValue().equals(""));
+ soap11FaultNode.setNodeValue("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Node Test : - After calling setNodeValue method, getNodeValue method returns incorrect value",
+ soap11FaultNode.getNodeValue().equals("This is only a test"));
+ }
+
+ //SOAP 1.2 Fault Node Test (Programaticaly Created)
+ public void testSOAP12SetNodeValue() {
+ soap12FaultNode.setNodeValue("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Node Test : - After calling setNodeValue method, getNodeValue method returns incorrect value",
+ soap12FaultNode.getNodeValue().equals("This is only a test"));
+ }
+
+ public void testSOAP12GetNodeValue() {
+ assertTrue(
+ "SOAP 1.2 Fault Node Test : - After creating SOAPFaultNode, it has a value",
+ soap12FaultNode.getNodeValue().equals(""));
+ soap12FaultNode.setNodeValue("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Node Test : - After calling setNodeValue method, getNodeValue method returns incorrect value",
+ soap12FaultNode.getNodeValue().equals("This is only a test"));
+ }
+
+ //SOAP 1.2 Fault Node Test (With Parser)
+ public void testSOAP12GetNodeValueWithParser() {
+ assertTrue(
+ "SOAP 1.2 Fault Node Test With Parser : - getNodeValue method returns incorrect value",
+ soap12FaultNodeWithParser.getNodeValue().trim().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultReasonTest.java b/test/org/apache/ws/commons/soap/SOAPFaultReasonTest.java
new file mode 100644
index 0000000..22f3ef8
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultReasonTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultReasonTest extends SOAPFaultReasonTestCase {
+
+ public SOAPFaultReasonTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP 1.1 Fault Reason Test (Programaticaly Created)
+ public void testSOAP11SetSOAPText() {
+ soap11FaultReason.setSOAPText(
+ soap11Factory.createSOAPFaultText(soap11FaultReason));
+ assertFalse(
+ "SOAP 1.1 FaultReason Test : - After calling setSOAPText, getSOAPText returns null",
+ soap11FaultReason.getSOAPText() == null);
+ try {
+ soap11FaultReason.setSOAPText(
+ soap12Factory.createSOAPFaultText(soap12FaultReason));
+ fail("SOAP12FaultText should not be added to SOAP11FaultReason");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP11GetSOAPText() {
+ assertTrue(
+ "SOAP 1.1 FaultReason Test : - After creating SOAP11FaultReason, it has a SOAPFaultText",
+ soap11FaultReason.getSOAPText() == null);
+ soap11FaultReason.setSOAPText(
+ soap11Factory.createSOAPFaultText(soap11FaultReason));
+ assertFalse(
+ "SOAP 1.1 FaultReason Test : - After calling setSOAPText, getSOAPText returns null",
+ soap11FaultReason.getSOAPText() == null);
+ }
+
+ //SOAP 1.2 Fault Reason Test (Programaticaly Created)
+ public void testSOAP12SetSOAPText() {
+ soap12FaultReason.setSOAPText(
+ soap12Factory.createSOAPFaultText(soap12FaultReason));
+ assertFalse(
+ "SOAP 1.2 FaultReason Test : - After calling setSOAPText, getSOAPText returns null",
+ soap12FaultReason.getSOAPText() == null);
+ try {
+ soap12FaultReason.setSOAPText(
+ soap11Factory.createSOAPFaultText(soap11FaultReason));
+ fail("SOAP11FaultText should not be added to SOAP12FaultReason");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetSOAPText() {
+ assertTrue(
+ "SOAP 1.2 FaultReason Test : - After creating SOAP12FaultReason, it has a SOAPFaultText",
+ soap12FaultReason.getSOAPText() == null);
+ soap12FaultReason.setSOAPText(
+ soap12Factory.createSOAPFaultText(soap12FaultReason));
+ assertFalse(
+ "SOAP 1.2 FaultReason Test : - After calling setSOAPText, getSOAPText returns null",
+ soap12FaultReason.getSOAPText() == null);
+ }
+
+ //SOAP 1.1 Fault Reason Test (With Parser)
+ public void testSOAP11GetSOAPTextWithParser() {
+ assertFalse(
+ "SOAP 1.1 FaultReason Test With Parser : - getSOAPText method returns null",
+ soap11FaultReasonWithParser.getSOAPText() == null);
+ }
+
+ //SOAP 1.2 Fault Reason Test (With Parser)
+ public void testSOAP12GetSOAPTextWithParser() {
+ assertFalse(
+ "SOAP 1.2 FaultReason Test With Parser : - getSOAPText method returns null",
+ soap12FaultReasonWithParser.getSOAPText() == null);
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultReasonTestCase.java b/test/org/apache/ws/commons/soap/SOAPFaultReasonTestCase.java
new file mode 100644
index 0000000..c0f57c9
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultReasonTestCase.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultReasonTestCase extends SOAPFaultTestCase {
+
+ protected SOAPFaultReason soap11FaultReason;
+ protected SOAPFaultReason soap12FaultReason;
+ protected SOAPFaultReason soap11FaultReasonWithParser;
+ protected SOAPFaultReason soap12FaultReasonWithParser;
+
+ public SOAPFaultReasonTestCase(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultReason = soap11Factory.createSOAPFaultReason(soap11Fault);
+ soap12FaultReason = soap12Factory.createSOAPFaultReason(soap12Fault);
+ soap11FaultReasonWithParser = soap11FaultWithParser.getReason();
+ soap12FaultReasonWithParser = soap12FaultWithParser.getReason();
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultRoleTest.java b/test/org/apache/ws/commons/soap/SOAPFaultRoleTest.java
new file mode 100644
index 0000000..38ff478
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultRoleTest.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultRoleTest extends SOAPFaultTestCase {
+
+ protected SOAPFaultRole soap11FaultRole;
+ protected SOAPFaultRole soap12FaultRole;
+ protected SOAPFaultRole soap11FaultRoleWithParser;
+ protected SOAPFaultRole soap12FaultRoleWithParser;
+
+ public SOAPFaultRoleTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultRole = soap11Factory.createSOAPFaultRole(soap11Fault);
+ soap12FaultRole = soap12Factory.createSOAPFaultRole(soap12Fault);
+ soap11FaultRoleWithParser = soap11FaultWithParser.getRole();
+ soap12FaultRoleWithParser = soap12FaultWithParser.getRole();
+ }
+
+ //SOAP 1.1 Fault Role Test (Programaticaly Created)
+ public void testSOAP11SetRoleValue() {
+ soap11FaultRole.setRoleValue("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Role Test : - After calling setRoleValue method, getRoleValue method returns incorrect value",
+ soap11FaultRole.getRoleValue().trim().equals("This is only a test"));
+ }
+
+ public void testSOAP11GetRoleValue() {
+ assertTrue(
+ "SOAP 1.1 Fault Role Test : - After creating SOAPFaultRole, it has a value",
+ soap11FaultRole.getRoleValue().equals(""));
+ soap11FaultRole.setRoleValue("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Role Test : - After calling setRoleValue method, getRoleValue method returns incorrect value",
+ soap11FaultRole.getRoleValue().trim().equals("This is only a test"));
+ }
+
+ //SOAP 1.2 Fault Role Test (Programaticaly Created)
+ public void testSOAP12SetRoleValue() {
+ soap12FaultRole.setRoleValue("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Role Test : - After calling setRoleValue method, getRoleValue method returns incorrect value",
+ soap12FaultRole.getRoleValue().trim().equals("This is only a test"));
+ }
+
+ public void testSOAP12GetRoleValue() {
+ assertTrue(
+ "SOAP 1.2 Fault Role Test : - After creating SOAPFaultRole, it has a value",
+ soap12FaultRole.getRoleValue().trim().equals(""));
+ soap12FaultRole.setRoleValue("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Role Test : - After calling setRoleValue method, getRoleValue method returns incorrect value",
+ soap12FaultRole.getRoleValue().trim().equals("This is only a test"));
+ }
+
+ //SOAP 1.1 Fault Role Test (With Parser)
+ public void testSOAP11GetRoleValueWithParser() {
+ assertTrue(
+ "SOAP 1.1 Fault Role Test With Parser : - getRoleValue method returns incorrect value",
+ soap11FaultRoleWithParser.getRoleValue().trim().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver"));
+ }
+
+ //SOAP 1.2 Fault Role Test (With Parser)
+ public void testSOAP12GetRoleValueWithParser() {
+ assertTrue(
+ "SOAP 1.2 Fault Role Test With Parser : - getRoleValue method returns incorrect value",
+ soap12FaultRoleWithParser.getRoleValue().trim().equals(
+ "ultimateReceiver"));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTest.java b/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTest.java
new file mode 100644
index 0000000..22bab48
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTest.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+
+public class SOAPFaultSubCodeTest extends SOAPFaultSubCodeTestCase {
+
+ public SOAPFaultSubCodeTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP Fault SubCode(In Fault Code) Test (Programaticaly Created)
+ public void testSetValueInFaultCode() {
+ soap12FaultSubCodeInCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultSubCodeInCode));
+ assertFalse(
+ "SOAP 1.2 Subcode Test In Fault Code : - After calling setValue method, getValue method returns null",
+ soap12FaultSubCodeInCode.getValue() == null);
+ try {
+ soap12FaultSubCodeInCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultCode));
+ } catch (SOAPProcessingException e) {
+ fail(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode : - FaultValue whose parent is FaultCode should not be set in to FaultSubCode, as a child");
+ }
+ }
+
+ public void testGetValueInFaultCode() {
+ assertTrue(
+ "After creating SOAP12FaultSubCode In Fault Code, it has a FaultValue",
+ soap12FaultSubCodeInCode.getValue() == null);
+ soap12FaultSubCodeInCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultSubCodeInCode));
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode : - After calling setValue method, getValue method returns null",
+ soap12FaultSubCodeInCode.getValue() == null);
+ }
+
+ public void testsetSubCodeInFaultCode() {
+ soap12FaultSubCodeInCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultSubCodeInCode));
+ assertFalse(
+ "SOAP 1.2 Subcode Test In Fault Code : - After calling setSubCode method, getSubCode method returns null",
+ soap12FaultSubCodeInCode.getSubCode() == null);
+ try {
+ soap12FaultSubCodeInCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultCode));
+ } catch (SOAPProcessingException e) {
+ fail(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode : - FaultSubCode whose parent is FaultCode should not be set in to FaultSubCode, as a child");
+ }
+ }
+
+ public void testGetSubCodeInFaultCode() {
+ //soap12FaultSubCodeInCode has a SubCode because a SubCode was created in setUp method of super class
+// assertTrue("After creating SOAP12FaultSubCode In Fault Code, it has a FaultSubCode",soap12FaultSubCodeInCode.getSubCode() == null);
+ soap12FaultSubCodeInCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultSubCodeInCode));
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode : - After calling setSubCode method, getSubCode method returns null",
+ soap12FaultSubCodeInCode.getSubCode() == null);
+ }
+
+ //SOAP Fault SubCode(In Fault SubCode) Test (Programaticaly Created)
+ public void testSetValueInFaultSubCode() {
+ soap12FaultSubCodeInSubCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultSubCodeInSubCode));
+ assertFalse(
+ "SOAP 1.2 Subcode Test In Fault SubCode : - After calling setValue method, getValue method returns null",
+ soap12FaultSubCodeInSubCode.getValue() == null);
+ try {
+ soap12FaultSubCodeInSubCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultCode));
+ } catch (SOAPProcessingException e) {
+ fail(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode : - FaultValue whose parent is FaultCode should not be set in to FaultSubCode, as a child");
+ }
+ }
+
+ public void testGetValueInFaultSubCode() {
+ assertTrue(
+ "After creating SOAP12FaultSubCode In Fault SubCode, it has a Fault Value",
+ soap12FaultSubCodeInSubCode.getValue() == null);
+ soap12FaultSubCodeInSubCode.setValue(
+ soap12Factory.createSOAPFaultValue(soap12FaultSubCodeInSubCode));
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode : - After calling setValue method, getValue method returns null",
+ soap12FaultSubCodeInSubCode.getValue() == null);
+ }
+
+ public void testsetSubCodeInFaultSubCode() {
+ soap12FaultSubCodeInSubCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(
+ soap12FaultSubCodeInSubCode));
+ assertFalse(
+ "SOAP 1.2 Subcode Test In Fault SubCode : - After calling setSubCode method, getSubCode method returns null",
+ soap12FaultSubCodeInSubCode.getSubCode() == null);
+ try {
+ soap12FaultSubCodeInSubCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(soap12FaultCode));
+ } catch (SOAPProcessingException e) {
+ fail(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode : - FaultSubCode whose parent is FaultCode should not be set in to FaultSubCode, as a child");
+ }
+ }
+
+ public void testGetSubCodeInFaultSubCode() {
+ assertTrue(
+ "After creating SOAP12FaultSubCode In Fault SubCode, it has a FaultSubCode",
+ soap12FaultSubCodeInSubCode.getSubCode() == null);
+ soap12FaultSubCodeInSubCode.setSubCode(
+ soap12Factory.createSOAPFaultSubCode(
+ soap12FaultSubCodeInSubCode));
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode : - After calling setSubCode method, getSubCode method returns null",
+ soap12FaultSubCodeInSubCode.getSubCode() == null);
+ }
+
+ //SOAP Fault SubCode(In Fault Code) Test (With Parser)
+ public void testGetValueInFaultCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode With Parser : - getValue method returns null",
+ soap12FaultSubCodeInFaultCodeWithParser.getValue() == null);
+ assertTrue(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode With Parser : - Value text mismatch",
+ soap12FaultSubCodeInFaultCodeWithParser.getValue().getText()
+ .equals("m:MessageTimeout In First Subcode"));
+ }
+
+ public void testGetSubCodeInFaultCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode With Parser : - getSubCode method returns null",
+ soap12FaultSubCodeInFaultCodeWithParser.getSubCode() == null);
+ assertTrue(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultCode With Parser : - SubCode local name mismatch",
+ soap12FaultSubCodeInFaultCodeWithParser.getSubCode()
+ .getLocalName()
+ .equals(SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME));
+ }
+
+ //SOAP Fault SubCode(In Fault SubCode) Test (With Parser)
+ public void testGetValueInFaultSubCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode With Parser : - getValue method returns null",
+ soap12FaultSubCodeInSubCodeWithParser.getValue() == null);
+ assertTrue(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode With Parser : - Value text mismatch",
+ soap12FaultSubCodeInSubCodeWithParser.getValue().getText()
+ .equals("m:MessageTimeout In Second Subcode"));
+ }
+
+ public void testGetSubCodeInFaultSubCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode With Parser : - getSubCode method returns null",
+ soap12FaultSubCodeInSubCodeWithParser.getSubCode() == null);
+ assertTrue(
+ "SOAP 1.2 SOAPFaultSubCode Test In FaultSubCode With Parser : - SubCode local name mismatch",
+ soap12FaultSubCodeInSubCodeWithParser.getSubCode()
+ .getLocalName()
+ .equals(SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTestCase.java b/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTestCase.java
new file mode 100644
index 0000000..1e5c859
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultSubCodeTestCase.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultSubCodeTestCase extends SOAPFaultCodeTestCase {
+ protected SOAPFaultValue soap11FaultValue;
+ protected SOAPFaultValue soap12FaultValueInFaultCode;
+ protected SOAPFaultSubCode soap12FaultSubCodeInCode;
+
+ protected SOAPFaultValue soap12FaultValueInFaultSubCode;
+ protected SOAPFaultSubCode soap12FaultSubCodeInSubCode;
+
+ protected SOAPFaultValue soap11FaultValueWithParser;
+ protected SOAPFaultValue soap12FaultValueInFaultCodeWithParser;
+ protected SOAPFaultSubCode soap12FaultSubCodeInFaultCodeWithParser;
+
+ protected SOAPFaultValue soap12FaultValueInFaultSubCodeWithParser;
+ protected SOAPFaultSubCode soap12FaultSubCodeInSubCodeWithParser;
+
+ public SOAPFaultSubCodeTestCase(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultValue = soap11Factory.createSOAPFaultValue(soap11FaultCode);
+
+ soap12FaultValueInFaultCode =
+ soap12Factory.createSOAPFaultValue(soap12FaultCode);
+ soap12FaultSubCodeInCode =
+ soap12Factory.createSOAPFaultSubCode(soap12FaultCode);
+
+
+ soap12FaultSubCodeInSubCode =
+ soap12Factory.createSOAPFaultSubCode(soap12FaultSubCodeInCode);
+
+ soap11FaultValueWithParser = soap11FaultCodeWithParser.getValue();
+ soap12FaultValueInFaultCodeWithParser =
+ soap12FaultCodeWithParser.getValue();
+ soap12FaultSubCodeInFaultCodeWithParser =
+ soap12FaultCodeWithParser.getSubCode();
+
+ soap12FaultValueInFaultSubCodeWithParser =
+ soap12FaultSubCodeInFaultCodeWithParser.getValue();
+ soap12FaultSubCodeInSubCodeWithParser =
+ soap12FaultSubCodeInFaultCodeWithParser.getSubCode();
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultTest.java b/test/org/apache/ws/commons/soap/SOAPFaultTest.java
new file mode 100644
index 0000000..3bec61b
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultTest.java
@@ -0,0 +1,416 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+
+public class SOAPFaultTest extends SOAPFaultTestCase {
+
+ public SOAPFaultTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP 1.1 Fault Test (Programaticaly created)-----------------------------------------------------------------------------------
+ public void testSOAP11SetCode() {
+ soap11Fault.setCode(soap11Factory.createSOAPFaultCode(soap11Fault));
+ assertNotNull(
+ "SOAP 1.1 Fault Test:- After calling setCode method, Fault has no code",
+ soap11Fault.getCode());
+ try {
+ soap11Fault.setCode(soap12Factory.createSOAPFaultCode(soap12Fault));
+ fail("SOAP12FaultCode should not not be set in to a SOAP11Fault");
+ } catch (Exception e) {
+ }
+ }
+
+ public void testSOAP11GetCode() {
+ assertTrue(
+ "SOAP 1.1 Fault Test:- After creating a SOAP11Fault, it has a code",
+ soap11Fault.getCode() == null);
+ soap11Fault.setCode(soap11Factory.createSOAPFaultCode(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setCode method, Fault has no code",
+ soap11Fault.getCode() == null);
+ }
+
+ public void testSOAP11SetReason() {
+ soap11Fault.setReason(soap11Factory.createSOAPFaultReason(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setReason method, Fault has no reason",
+ soap11Fault.getReason() == null);
+ try {
+ soap11Fault.setReason(
+ soap12Factory.createSOAPFaultReason(soap12Fault));
+ fail("SOAP12FaultReason should not be set in to a SOAP11Fault");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP11GetReason() {
+ assertTrue(
+ "SOAP 1.1 Fault Test:- After creating a SOAP11Fault, it has a reason",
+ soap11Fault.getReason() == null);
+ soap11Fault.setReason(soap11Factory.createSOAPFaultReason(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setReason method, Fault has no reason",
+ soap11Fault.getReason() == null);
+ }
+
+ public void testSOAP11SetNode() {
+ soap11Fault.setNode(soap11Factory.createSOAPFaultNode(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setNode method, Fault has no node",
+ soap11Fault.getNode() == null);
+ try {
+ soap11Fault.setNode(soap12Factory.createSOAPFaultNode(soap12Fault));
+ fail("SOAP12FaultNode should not be set in to a SOAP11Fault");
+
+ } catch (Exception e) {
+ assertTrue(true);
+
+ }
+ }
+
+ public void testSOAP11GetNode() {
+ assertTrue(
+ "SOAP 1.1 Fault Test:- After creating a SOAP11Fault, it has a node",
+ soap11Fault.getNode() == null);
+ soap11Fault.setNode(soap11Factory.createSOAPFaultNode(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setNode method, Fault has no node",
+ soap11Fault.getNode() == null);
+ }
+
+ public void testSOAP11SetRole() {
+ soap11Fault.setRole(soap11Factory.createSOAPFaultRole(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setRole method, Fault has no role",
+ soap11Fault.getRole() == null);
+ try {
+ soap11Fault.setRole(soap12Factory.createSOAPFaultRole(soap12Fault));
+ fail("SOAP12FaultRole should not be set in to a SOAP11Fault");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP11GetRole() {
+ assertTrue(
+ "SOAP 1.1 Fault Test:- After creating a SOAP11Fault, it has a role",
+ soap11Fault.getRole() == null);
+ soap11Fault.setRole(soap11Factory.createSOAPFaultRole(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setRole method, Fault has no role",
+ soap11Fault.getRole() == null);
+ }
+
+ public void testSOAP11SetDetail() {
+ soap11Fault.setDetail(soap11Factory.createSOAPFaultDetail(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setDetail method, Fault has no detail",
+ soap11Fault.getDetail() == null);
+ try {
+ soap11Fault.setDetail(
+ soap12Factory.createSOAPFaultDetail(soap12Fault));
+ fail("SOAP12FaultDetail should not be set in to a SOAP11Fault");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP11GetDetail() {
+ assertTrue(
+ "SOAP 1.1 Fault Test:- After creating a SOAP11Fault, it has a detail",
+ soap11Fault.getDetail() == null);
+ soap11Fault.setDetail(soap11Factory.createSOAPFaultDetail(soap11Fault));
+ assertFalse(
+ "SOAP 1.1 Fault Test:- After calling setDetail method, Fault has no detail",
+ soap11Fault.getDetail() == null);
+ }
+
+ //SOAP 1.2 Fault Test ((Programaticaly created)--------------------------------------------------------------------------------
+ public void testSOAP12SetCode() {
+ soap12Fault.setCode(soap12Factory.createSOAPFaultCode(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setCode method, Fault has no code",
+ soap12Fault.getCode() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Code local name mismatch",
+ soap12Fault.getCode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME));
+ try {
+ soap12Fault.setCode(soap11Factory.createSOAPFaultCode(soap11Fault));
+ fail("SOAP11FaultCode should not be set in to a SOAP12Fault");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Test:- After creating a SOAP12Fault, it has a code",
+ soap12Fault.getCode() == null);
+ soap12Fault.setCode(soap12Factory.createSOAPFaultCode(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setCode method, Fault has no code",
+ soap12Fault.getCode() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault code local name mismatch",
+ soap12Fault.getCode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME));
+ }
+
+ public void testSOAP12SetReason() {
+ soap12Fault.setReason(soap12Factory.createSOAPFaultReason(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setReason method, Fault has no reason",
+ soap12Fault.getReason() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault reason local name mismatch",
+ soap12Fault.getReason().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME));
+ try {
+ soap12Fault.setReason(
+ soap11Factory.createSOAPFaultReason(soap11Fault));
+ fail("SOAP11FaultReason should not be set in to a SOAP12Fault");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetReason() {
+ assertTrue(
+ "SOAP 1.2 Fault Test:- After creating a SOAP12Fault, it has a reason",
+ soap12Fault.getReason() == null);
+ soap12Fault.setReason(soap12Factory.createSOAPFaultReason(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setReason method, Fault has no reason",
+ soap12Fault.getReason() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault reason local name mismatch",
+ soap12Fault.getReason().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME));
+ }
+
+ public void testSOAP12SetNode() {
+ soap12Fault.setNode(soap12Factory.createSOAPFaultNode(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setNode method, Fault has no node",
+ soap12Fault.getNode() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault node local name mismatch",
+ soap12Fault.getNode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME));
+ try {
+ soap12Fault.setNode(soap11Factory.createSOAPFaultNode(soap11Fault));
+ fail("SOAP11FaultNode should nott be set in to a SOAP12Fault");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetNode() {
+ assertTrue(
+ "SOAP 1.2 Fault Test:- After creating a SOAP12Fault, it has a node",
+ soap12Fault.getNode() == null);
+ soap12Fault.setNode(soap12Factory.createSOAPFaultNode(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setNode method, Fault has no node",
+ soap12Fault.getNode() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault node local name mismatch",
+ soap12Fault.getNode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME));
+ }
+
+ public void testSOAP12SetRole() {
+ soap12Fault.setRole(soap12Factory.createSOAPFaultRole(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 :- After calling setRole method, Fault has no role",
+ soap12Fault.getRole() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault role local name mismatch",
+ soap12Fault.getRole().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME));
+ try {
+ soap12Fault.setRole(soap11Factory.createSOAPFaultRole(soap11Fault));
+ fail("SOAP11FaultRole should not be set in to a SOAP12Fault");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetRole() {
+ assertTrue(
+ "SOAP 1.2 Fault Test:- After creating a SOAP11Fault, it has a role",
+ soap12Fault.getRole() == null);
+ soap12Fault.setRole(soap12Factory.createSOAPFaultRole(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setRole method, Fault has no role",
+ soap12Fault.getRole() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault role local name mismatch",
+ soap12Fault.getRole().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME));
+ }
+
+ public void testSOAP12SetDetail() {
+ soap12Fault.setDetail(soap12Factory.createSOAPFaultDetail(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setDetaile method, Fault has no detail",
+ soap12Fault.getDetail() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault detail local name mismatch",
+ soap12Fault.getDetail().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME));
+ try {
+ soap12Fault.setDetail(
+ soap11Factory.createSOAPFaultDetail(soap11Fault));
+ fail("SOAP11FaultDetail should not be set in to a SOAP12Fault");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetDetail() {
+ assertTrue(
+ "SOAP 1.2 Fault Test:- After creating a SOAP12Fault, it has a detail",
+ soap12Fault.getDetail() == null);
+ soap12Fault.setDetail(soap12Factory.createSOAPFaultDetail(soap12Fault));
+ assertFalse(
+ "SOAP 1.2 Fault Test:- After calling setDetail method, Fault has no detail",
+ soap12Fault.getDetail() == null);
+ assertTrue("SOAP 1.2 Fault Test:- Fault detail local name mismatch",
+ soap12Fault.getDetail().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME));
+ }
+
+ //SOAP 1.1 Fault Test (With parser)
+ public void testSOAP11GetCodeWithParser() {
+ assertFalse(
+ "SOAP 1.1 Fault Test with parser: - getCode method returns null",
+ soap11FaultWithParser.getCode() == null);
+ }
+
+ public void testSOAP11GetRoleWithParser() {
+ assertFalse(
+ "SOAP 1.1 Fault Test with parser: - getRole method returns null",
+ soap11FaultWithParser.getRole() == null);
+ }
+
+ public void testSOAP11GetDetailWithParser() {
+ assertFalse(
+ "SOAP 1.1 Fault Test with parser: - getDetail method returns null",
+ soap11FaultWithParser.getDetail() == null);
+ }
+
+ //SOAP 1.2 Fault Test (With parser)
+ public void testSOAP12GetCodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Test with parser: - getCode method returns null",
+ soap12FaultWithParser.getCode() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Test with parser: - Fault code local name mismatch",
+ soap12FaultWithParser.getCode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME));
+ }
+
+ public void testSOAP12GetReasonWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Test with parser: - getReason method returns null",
+ soap12FaultWithParser.getReason() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Test with parser: - Fault reason local name mismatch",
+ soap12FaultWithParser.getReason().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME));
+ }
+
+ public void testSOAP12GetNodeWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Test with parser: - getNode method returns null",
+ soap12FaultWithParser.getNode() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Test with parser: - Fault node local name mismatch",
+ soap12FaultWithParser.getNode().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME));
+ }
+
+ public void testSOAP12GetRoleWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Test with parser: - getRole method returns null",
+ soap12FaultWithParser.getRole() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Test with parser: - Fault role local name mismatch",
+ soap12FaultWithParser.getRole().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME));
+ }
+
+ public void testSOAP12GetDetailWithParser() {
+ assertFalse(
+ "SOAP 1.2 Fault Test with parser: - getDetail method returns null",
+ soap12FaultWithParser.getDetail() == null);
+ assertTrue(
+ "SOAP 1.2 Fault Test with parser: - Fault detail local name mismatch",
+ soap12FaultWithParser.getDetail().getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME));
+ }
+
+ public void testMoreChildrenAddition() {
+ try {
+ SOAPFactory soapFactory = OMAbstractFactory.getSOAP12Factory();
+ SOAPEnvelope envelope = soapFactory.getDefaultFaultEnvelope();
+
+ assertNotNull("Default FaultEnvelope must have a SOAPFault in it",
+ envelope.getBody().getFault());
+ assertNotNull(
+ "Default FaultEnvelope must have a SOAPFaultCode in it",
+ envelope.getBody().getFault().getCode());
+ assertNotNull(
+ "Default FaultEnvelope must have a SOAPFaultCodeValue in it",
+ envelope.getBody().getFault().getCode().getValue());
+ assertNotNull(
+ "Default FaultEnvelope must have a SOAPFaultReason in it",
+ envelope.getBody().getFault().getReason());
+ assertNotNull(
+ "Default FaultEnvelope must have a SOAPFaultText in it",
+ envelope.getBody().getFault().getReason().getSOAPText());
+
+ SOAPEnvelope soapEnvelope = soapFactory.getDefaultFaultEnvelope();
+ String errorCodeString = "Some Error occurred !!";
+ soapEnvelope.getBody().getFault().getCode().getValue().setText(
+ errorCodeString);
+
+ SOAPFaultCode code = soapEnvelope.getBody().getFault().getCode();
+ envelope.getBody().getFault().setCode(code);
+
+ assertTrue("Parent Value of Code has not been set to new fault",
+ code.getParent() == envelope.getBody().getFault());
+ assertTrue("Parent Value of Code is still pointing to old fault",
+ code.getParent() != soapEnvelope.getBody().getFault());
+ assertNull("Old fault must not have a fault code",
+ soapEnvelope.getBody().getFault().getCode());
+ assertEquals("The SOAP Code value must be " + errorCodeString,
+ errorCodeString,
+ envelope.getBody().getFault().getCode().getValue().getText());
+
+ } catch (Exception e) {
+ fail(e.getMessage());
+ }
+
+
+ }
+}
\ No newline at end of file
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultTestCase.java b/test/org/apache/ws/commons/soap/SOAPFaultTestCase.java
new file mode 100644
index 0000000..d70d559
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultTestCase.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+
+public class SOAPFaultTestCase extends SOAPBodyTestCase {
+ protected SOAPFault soap11Fault;
+ protected SOAPFault soap12Fault;
+ protected SOAPFault soap11FaultWithParser;
+ protected SOAPFault soap12FaultWithParser;
+
+ public SOAPFaultTestCase(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11Fault =
+ OMAbstractFactory.getSOAP11Factory().createSOAPFault(
+ soap11Body);
+ soap12Fault =
+ OMAbstractFactory.getSOAP12Factory().createSOAPFault(
+ soap12Body);
+ soap11FaultWithParser = soap11BodyWithParser.getFault();
+ soap12FaultWithParser = soap12BodyWithParser.getFault();
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultTextTest.java b/test/org/apache/ws/commons/soap/SOAPFaultTextTest.java
new file mode 100644
index 0000000..eda4163
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultTextTest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMAttribute;
+
+public class SOAPFaultTextTest extends SOAPFaultReasonTestCase {
+ protected SOAPFaultText soap11FaultText;
+ protected SOAPFaultText soap12FaultText;
+ protected SOAPFaultText soap11FaultTextWithParser;
+ protected SOAPFaultText soap12FaultTextWithParser;
+
+ public SOAPFaultTextTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11FaultText = soap11Factory.createSOAPFaultText(soap11FaultReason);
+ soap12FaultText = soap12Factory.createSOAPFaultText(soap12FaultReason);
+ soap11FaultTextWithParser = soap11FaultReasonWithParser.getSOAPText();
+ soap12FaultTextWithParser = soap12FaultReasonWithParser.getSOAPText();
+ }
+
+ //SOAP 1.1 Fault Text Test (Programaticaly Created)
+ public void testSOAP11SetLang() {
+ soap11FaultText.setLang("en");
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setLang method, Lang attribute value mismatch",
+ soap11FaultText.getLang().equals("en"));
+ OMAttribute langAttribute = (OMAttribute) soap11FaultText.getAllAttributes()
+ .next();
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setLang method, Lang attribute local name mismaatch",
+ langAttribute.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME));
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setLang method, Lang attribute namespace prefix mismatch",
+ langAttribute.getNamespace().getPrefix().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX));
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setLang method, Lang attribute namespace uri mismatch",
+ langAttribute.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_URI));
+ }
+
+ public void testSOAP11GetLang() {
+
+
+ assertNull(
+ "SOAP 1.1 Fault Text Test : - After creating SOAPFaultText, it has a Lnag attribute",
+ soap11FaultText.getLang());
+
+ soap11FaultText.setLang("en");
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setLang method, Lang attribute value mismatch",
+ soap11FaultText.getLang().equals("en"));
+ }
+
+ public void testSOAP11SetText() {
+ soap11FaultText.setText("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setText method, getText method return incorrect string",
+ soap11FaultText.getText().equals("This is only a test"));
+ }
+
+ public void testSOAP11GetText() {
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After creating SOAPFaultText, it has a text",
+ soap11FaultText.getText().equals(""));
+ soap11FaultText.setText("This is only a test");
+ assertTrue(
+ "SOAP 1.1 Fault Text Test : - After calling setText method, getText method return incorrect string",
+ soap11FaultText.getText().equals("This is only a test"));
+ }
+
+ //SOAP 1.2 Fault Text Test (Programaticaly Created)
+ public void testSOAP12SetLang() {
+ soap12FaultText.setLang("en");
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setLang method, Lang attribute value mismatch",
+ soap12FaultText.getLang().equals("en"));
+ OMAttribute langAttribute = (OMAttribute) soap12FaultText.getAllAttributes()
+ .next();
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setLang method, Lang attribute local name mismaatch",
+ langAttribute.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME));
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setLang method, Lang attribute namespace prefix mismatch",
+ langAttribute.getNamespace().getPrefix().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX));
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setLang method, Lang attribute namespace uri mismatch",
+ langAttribute.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_URI));
+ }
+
+ public void testSOAP12GetLang() {
+
+ assertNull(
+ "SOAP 1.2 Fault Text Test : - After creating SOAPFaultText, it has a Lnag attribute",
+ soap12FaultText.getLang());
+
+ soap12FaultText.setLang("en");
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setLang method, Lang attribute value mismatch",
+ soap12FaultText.getLang().equals("en"));
+ }
+
+ public void testSOAP12SetText() {
+ soap12FaultText.setText("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setText method, getText method return incorrect string",
+ soap12FaultText.getText().equals("This is only a test"));
+ }
+
+ public void testSOAP12GetText() {
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After creating SOAPFaultText, it has a text",
+ soap12FaultText.getText().equals(""));
+ soap12FaultText.setText("This is only a test");
+ assertTrue(
+ "SOAP 1.2 Fault Text Test : - After calling setText method, getText method return incorrect string",
+ soap12FaultText.getText().equals("This is only a test"));
+ }
+
+ //SOAP 1.1 Fault Text Test (With Parser)
+ public void testSOAP11GetTextWithParser() {
+ assertTrue(
+ "SOAP 1.1 Fault Text Test With Parser : - getText method returns incorrect string",
+ soap11FaultTextWithParser.getText().trim().equals("Sender Timeout"));
+ }
+
+ //SOAP 1.2 Fault Text Test (With Parser)
+ public void testSOAP12GetLangWithParser() {
+ assertTrue(
+ "SOAP 1.2 Fault Text Test With Parser : - getLang method returns incorrect string",
+ soap12FaultTextWithParser.getLang().equals("en"));
+ OMAttribute langAttribute = (OMAttribute) soap12FaultTextWithParser.getAllAttributes()
+ .next();
+ assertTrue(
+ "SOAP 1.2 Fault Text Test With Parser : - Lang attribute local name mismaatch",
+ langAttribute.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_LOCAL_NAME));
+ assertTrue(
+ "SOAP 1.2 Fault Text Test With Parser : - Lang attribute namespace prefix mismatch",
+ langAttribute.getNamespace().getPrefix().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_PREFIX));
+ assertTrue(
+ "SOAP 1.2 Fault Text Test With Parser : - Lang attribute namespace uri mismatch",
+ langAttribute.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LANG_ATTR_NS_URI));
+ }
+
+ public void testSOAP12GetTextWithParser() {
+
+ assertTrue(
+ "SOAP 1.2 Fault Text Test With Parser : - getText method returns incorrect string",
+ soap12FaultTextWithParser.getText().equals("Sender Timeout"));
+
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPFaultValueTest.java b/test/org/apache/ws/commons/soap/SOAPFaultValueTest.java
new file mode 100644
index 0000000..009f080
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPFaultValueTest.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+public class SOAPFaultValueTest extends SOAPFaultSubCodeTestCase {
+
+ public SOAPFaultValueTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap12FaultValueInFaultSubCode =
+ soap12Factory.createSOAPFaultValue(soap12FaultSubCodeInCode);
+ }
+
+ //SOAP 1.1 Fault Value Test (Programaticaly Created)
+ public void testSOAP11setText() {
+ soap11FaultValue.setText("This is only Test");
+ assertTrue("SOAP 1.1 Fault Value Test : - value text mismatch",
+ soap11FaultValue.getText().equals("This is only Test"));
+ }
+
+ public void testSOAP11GetText() {
+ assertTrue(
+ "SOAP 1.1 Fault Value Test : - After creating Fault Value, it has a text",
+ soap11FaultValue.getText().equals(""));
+ soap11FaultValue.setText("This is only Test");
+ assertFalse(
+ "SOAP 1.1 Fault Value Test : - After calling setText method, getText method returns null",
+ soap11FaultValue.getText().equals(""));
+ assertTrue("SOAP 1.1 Fault Value Test : - value text mismatch",
+ soap11FaultValue.getText().equals("This is only Test"));
+ }
+
+ //SOAP 1.2 Fault Value(In Fault Code) Test (Programaticaly Created)
+ public void testSOAP12setTextInFaultCode() {
+ soap12FaultValueInFaultCode.setText("This is only Test");
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault Code : - value text mismatch",
+ soap12FaultValueInFaultCode.getText().equals(
+ "This is only Test"));
+ }
+
+ public void testSOAP12GetTextInFaultCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault Code : - After creating Fault Value, it has a text",
+ soap12FaultValueInFaultCode.getText().equals(""));
+ soap12FaultValueInFaultCode.setText("This is only Test");
+ assertFalse(
+ "SOAP 1.2 Fault Value Test in Fault Code : - After calling setText method, getText method returns null",
+ soap12FaultValueInFaultCode.getText().equals(""));
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault Code : - value text mismatch",
+ soap12FaultValueInFaultCode.getText().equals(
+ "This is only Test"));
+ }
+
+ //SOAP 1.2 Fault Value(In Fault SubCode) Test (Programaticaly Created)
+ public void testSOAP12setTextInFaultSubCode() {
+ soap12FaultValueInFaultSubCode.setText("This is only Test");
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault SubCode : - value text mismatch",
+ soap12FaultValueInFaultSubCode.getText().equals(
+ "This is only Test"));
+ }
+
+ public void testSOAP12GetTextInFaultSubCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault SubCode : - After creating Fault Value, it has a text",
+ soap12FaultValueInFaultSubCode.getText().equals(""));
+ soap12FaultValueInFaultSubCode.setText("This is only Test");
+ assertFalse(
+ "SOAP 1.2 Fault Value Test in Fault SubCode : - After calling setText method, getText method returns null",
+ soap12FaultValueInFaultSubCode.getText().equals(""));
+ assertTrue(
+ "SOAP 1.2 Fault Value Test in Fault SubCode : - value text mismatch",
+ soap12FaultValueInFaultSubCode.getText().equals(
+ "This is only Test"));
+ }
+
+ //SOAP 1.1 Fault Value Test (With Parser)
+ public void testSOAP11GetTextWithParser() {
+ assertTrue(
+ "SOAP 1.1 Fault Value Test with parser : - value text mismatch",
+ soap11FaultValueWithParser.getText().trim().equals("env:Sender"));
+ }
+
+ //SOAP 1.2 Fault Value(In Fault Code) Test (With Parser)
+ public void testSOAP12setTextWithParserInFaultCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Value Test with parser in Fault Code : - value text mismatch",
+ soap12FaultValueInFaultCodeWithParser.getText().equals(
+ "env:Sender"));
+ }
+
+ //SOAP 1.2 Fault Value(In Fault SubCode) Test (With Parser)
+ public void testSOAP12setTextWithParserInFaultSubCode() {
+ assertTrue(
+ "SOAP 1.2 Fault Value Test with parser in Fault SubCode : - value text mismatch",
+ soap12FaultValueInFaultSubCodeWithParser.getText().equals(
+ "m:MessageTimeout In First Subcode"));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPHeaderBlockTest.java b/test/org/apache/ws/commons/soap/SOAPHeaderBlockTest.java
new file mode 100644
index 0000000..aba3b7f
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPHeaderBlockTest.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import java.util.Iterator;
+
+public class SOAPHeaderBlockTest extends SOAPHeaderTestCase {
+ protected SOAPHeaderBlock soap11HeaderBlock;
+ protected SOAPHeaderBlock soap12HeaderBlock;
+ protected SOAPHeaderBlock soap11HeaderBlock1WithParser;
+ protected SOAPHeaderBlock soap12HeaderBlock1WithParser;
+ protected SOAPHeaderBlock soap11HeaderBlock2WithParser;
+ protected SOAPHeaderBlock soap12HeaderBlock2WithParser;
+ protected SOAPHeaderBlock soap11HeaderBlock3WithParser;
+ protected SOAPHeaderBlock soap12HeaderBlock3WithParser;
+
+ public SOAPHeaderBlockTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11HeaderBlock =
+ soap11Factory.createSOAPHeaderBlock("testHeaderBlock",
+ namespace,
+ soap11Header);
+ soap12HeaderBlock =
+ soap12Factory.createSOAPHeaderBlock("testHeaderBlock",
+ namespace,
+ soap12Header);
+ Iterator iterator = soap11HeaderWithParser.examineAllHeaderBlocks();
+ iterator.next();
+ soap11HeaderBlock1WithParser = (SOAPHeaderBlock) iterator.next();
+ iterator.next();
+ soap11HeaderBlock2WithParser = (SOAPHeaderBlock) iterator.next();
+ iterator.next();
+ soap11HeaderBlock3WithParser = (SOAPHeaderBlock) iterator.next();
+
+ iterator = soap12HeaderWithParser.examineAllHeaderBlocks();
+ iterator.next();
+ soap12HeaderBlock1WithParser = (SOAPHeaderBlock) iterator.next();
+ iterator.next();
+ soap12HeaderBlock2WithParser = (SOAPHeaderBlock) iterator.next();
+ iterator.next();
+ soap12HeaderBlock3WithParser = (SOAPHeaderBlock) iterator.next();
+ }
+
+ //SOAP 1.1 SOAPHeaderBlock Test (Programaticaly Created)
+ public void testSOAP11SetRole() {
+ soap11HeaderBlock.setRole(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next");
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After calling setRole method, getRole method returns incorrect role value",
+ soap11HeaderBlock.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next"));
+ try {
+ soap11HeaderBlock.setRole("Any Value");
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.1 HeaderBlock Test : - role value can not be set to any value");
+ }
+ }
+
+ public void testSOAP11GetRole() {
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After creating SOAPHeaderBlock, it has a role",
+ soap11HeaderBlock.getRole() == null);
+ soap11HeaderBlock.setRole(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next");
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After calling setRole method, getRole method returns incorrect role value",
+ soap11HeaderBlock.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next"));
+ }
+
+ public void testSOAP11SetMustUnderstand() {
+ soap11HeaderBlock.setMustUnderstand(true);
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After setting MustUnderstand true calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap11HeaderBlock.getMustUnderstand());
+ soap11HeaderBlock.setMustUnderstand(false);
+ assertFalse(
+ "SOAP 1.1 HeaderBlock Test : - After setting MustUnderstand false calling setMustUnderstand method , getMustUnderstand method returns true",
+ soap11HeaderBlock.getMustUnderstand());
+ soap11HeaderBlock.setMustUnderstand("1");
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After setting MustUnderstand \"1\" calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap11HeaderBlock.getMustUnderstand());
+ soap11HeaderBlock.setMustUnderstand("0");
+ assertFalse(
+ "SOAP 1.1 HeaderBlock Test : - After setting MustUnderstand \"0\" calling setMustUnderstand method , getMustUnderstand method returns true",
+ soap11HeaderBlock.getMustUnderstand());
+ try {
+ soap11HeaderBlock.setMustUnderstand("true");
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.1 HeaderBlock Test : - MustUnderstatnd value can not be set to any value rather than 1 or 0");
+ }
+ }
+
+ public void testSOAP11GetMustUnderstand() {
+ assertFalse(
+ "SOAP 1.1 HeaderBlock Test : - After creating SOAPHeaderBlock, default MustUnderstand value true",
+ soap11HeaderBlock.getMustUnderstand());
+ soap11HeaderBlock.setMustUnderstand(true);
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test : - After setting MustUnderstand true calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap11HeaderBlock.getMustUnderstand());
+ }
+
+ //SOAP 1.2 SOAPHeaderBlock Test (Programaticaly Created)
+ public void testSOAP12SetRole() {
+ soap12HeaderBlock.setRole(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After calling setRole method, getRole method returns incorrect role value",
+ soap12HeaderBlock.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ try {
+ soap12HeaderBlock.setRole("Any Value");
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.2 HeaderBlock Test : - role value can not be set to any value");
+ }
+ }
+
+ public void testSOAP12GetRole() {
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After creating SOAPHeaderBlock, it has a role",
+ soap12HeaderBlock.getRole() == null);
+ soap12HeaderBlock.setRole(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After calling setRole method, getRole method returns incorrect role value",
+ soap12HeaderBlock.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ }
+
+ public void testSOAP12SetMustUnderstand() {
+ soap12HeaderBlock.setMustUnderstand(true);
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand true calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand(false);
+ assertFalse(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand false calling setMustUnderstand method , getMustUnderstand method returns true",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand("true");
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand \"true\" calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand("false");
+ assertFalse(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand \"false\" calling setMustUnderstand method , getMustUnderstand method returns true",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand("1");
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand \"1\" calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand("0");
+ assertFalse(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand \"0\" calling setMustUnderstand method , getMustUnderstand method returns true",
+ soap12HeaderBlock.getMustUnderstand());
+ try {
+ soap12HeaderBlock.setMustUnderstand("otherValue");
+ fail(
+ "SOAP 1.2 HeaderBlock Test : - MustUnderstatnd value can not be set to any value rather than 1 , 0 , true , false");
+
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+ }
+
+ public void testSOAP12GetMustUnderstand() {
+ assertFalse(
+ "SOAP 1.2 HeaderBlock Test : - After creating SOAPHeaderBlock, default MustUnderstand value true",
+ soap12HeaderBlock.getMustUnderstand());
+ soap12HeaderBlock.setMustUnderstand(true);
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test : - After setting MustUnderstand true calling setMustUnderstand method , getMustUnderstand method returns false",
+ soap12HeaderBlock.getMustUnderstand());
+ }
+
+ //SOAP 1.1 SOAPHeaderBlock Test (With Parser)
+ public void testSOAP11GetRoleWithParser() {
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test Wiht Parser : - getRole method returns incorrect role value",
+ soap11HeaderBlock1WithParser.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/actor/next"));
+ }
+
+ public void testSOAP11GetMustUnderstandWithParser() {
+ assertTrue(
+ "SOAP 1.1 HeaderBlock Test Wiht Parser : - getMustUnderstatnd method returns incorrect value",
+ soap11HeaderBlock2WithParser.getMustUnderstand());
+ assertFalse(
+ "SOAP 1.1 HeaderBlock Test Wiht Parser : - getMustUnderstatnd method returns incorrect value",
+ soap11HeaderBlock3WithParser.getMustUnderstand());
+
+ }
+
+ //SOAP 1.2 SOAPHeaderBlock Test (With Parser)
+ public void testSOAP12GetRoleWithParser() {
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test Wiht Parser : - getRole method returns incorrect role value",
+ soap12HeaderBlock1WithParser.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ }
+
+ public void testSOAP12GetMustUnderstandWithParser() {
+ assertTrue(
+ "SOAP 1.2 HeaderBlock Test Wiht Parser : - getMustUnderstatnd method returns incorrect value",
+ soap12HeaderBlock1WithParser.getMustUnderstand());
+ assertFalse(
+ "SOAP 1.2 HeaderBlock Test Wiht Parser : - getMustUnderstatnd method returns incorrect value",
+ soap12HeaderBlock2WithParser.getMustUnderstand());
+ try {
+ soap12HeaderBlock3WithParser.getMustUnderstand();
+ } catch (Exception e) {
+ fail(
+ "SOAP 1.2 HeaderBlock Test Wiht Parser : - getMustUnderstatnd method should returns exception when mustunderstand value is incorrect");
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPHeaderTest.java b/test/org/apache/ws/commons/soap/SOAPHeaderTest.java
new file mode 100644
index 0000000..52d610c
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPHeaderTest.java
@@ -0,0 +1,465 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class SOAPHeaderTest extends SOAPHeaderTestCase {
+ protected boolean isThereException;
+
+ public SOAPHeaderTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ //SOAP 1.1 Header Test (Programaticaly Created)--------------------------------------------------------------------------------
+ public void testSOAP11AddHeadearBlock() {
+ soap11Header.addHeaderBlock("echoOk1", namespace);
+ soap11Header.addHeaderBlock("echoOk2", namespace);
+ Iterator iterator = soap11Header.getChildren();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, getChildren method returns empty iterator",
+ headerBlock1 == null);
+ assertTrue("SOAP 1.1 Header Test : - HeaderBlock1 local name mismatch",
+ headerBlock1.getLocalName().equals("echoOk1"));
+ assertTrue(
+ "SOAP 1.1 Header Test : - HeaderBlock1 namespace uri mismatch",
+ headerBlock1.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, getChildren method returns an iterator with only one object",
+ headerBlock2 == null);
+ assertTrue("SOAP 1.1 Header Test : - HeaderBlock2 local name mismatch",
+ headerBlock2.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.1 Header Test : - HeaderBlock2 namespace uri mismatch",
+ headerBlock2.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ assertTrue(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, getChildren method returns an iterator with more than two object",
+ iterator.next() == null);
+ }
+
+ public void testSOAP11ExamineHeaderBlocks() {
+ soap11Header.addHeaderBlock("echoOk1", namespace).setRole(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver");
+ soap11Header.addHeaderBlock("echoOk2", namespace).setRole(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next");
+ Iterator iterator = soap11Header.examineHeaderBlocks(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlockWithRole1 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test : - headerBlockWithRole local name mismatch",
+ headerBlockWithRole1.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.1 Header Test : - headerBlockWithRole role value mismatch",
+ headerBlockWithRole1.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/next"));
+
+
+ assertFalse(
+ "SOAP 1.1 Header Test : - header has three headerBlocks with the given role, but examineHeaderBlocks(String role) method returns an iterator with more than three objects",
+ iterator.hasNext());
+ }
+
+// public void testSOAP11ExtractHeaderBlocks() {
+
+// }
+
+
+
+ public void testSOAP11ExamineAllHeaderBlocks() {
+ soap11Header.addHeaderBlock("echoOk1", namespace);
+ soap11Header.addHeaderBlock("echoOk2", namespace);
+ Iterator iterator = soap11Header.examineAllHeaderBlocks();
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns empty iterator",
+ headerBlock1 == null);
+ assertTrue("SOAP 1.1 Header Test : - HeaderBlock1 local name mismatch",
+ headerBlock1.getLocalName().equals("echoOk1"));
+ assertTrue(
+ "SOAP 1.1 Header Test : - HeaderBlock1 namespace uri mismatch",
+ headerBlock1.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns an iterator with only one object",
+ headerBlock2 == null);
+ assertTrue("SOAP 1.1 Header Test : - HeaderBlock2 local name mismatch",
+ headerBlock2.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.1 Header Test : - HeaderBlock2 namespace uri mismatch",
+ headerBlock2.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ assertFalse(
+ "SOAP 1.1 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns an iterator with more than two object",
+ iterator.hasNext());
+
+ }
+
+// public void testSOAP11ExtractAllHeaderBlocks() {
+//
+// }
+
+
+ public void testSOAP11getHeaderBlocksWithNSURI() {
+ soap11Header.addHeaderBlock("echoOk1", namespace);
+ soap11Header.addHeaderBlock("echoOk2",
+ omFactory.createOMNamespace("http://www.test1.org", "test1"));
+ ArrayList arrayList = soap11Header.getHeaderBlocksWithNSURI(
+ "http://www.test1.org");
+ assertTrue(
+ "SOAP 1.1 Header Test : - getHeaderBlocksWithNSURI returns an arrayList of incorrect size",
+ arrayList.size() == 1);
+ assertTrue(
+ "SOAP 1.1 Header Test : - headerBlock of given namespace uri mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getNamespace().getName()
+ .equals("http://www.test1.org"));
+ }
+
+ //SOAP 1.2 Header Test (Programaticaly Created)----------------------------------------------------------------------------------
+ public void testSOAP12AddHeadearBlock() {
+ soap12Header.addHeaderBlock("echoOk1", namespace);
+ soap12Header.addHeaderBlock("echoOk2", namespace);
+ Iterator iterator = soap12Header.getChildren();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method, getChildren method returns empty iterator",
+ headerBlock1 == null);
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock1 local name mismatch",
+ headerBlock1.getLocalName().equals("echoOk1"));
+ assertTrue(
+ "SOAP 1.2 Header Test : - HeaderBlock1 namespace uri mismatch",
+ headerBlock1.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method, getChildren method returns an iterator with only one object",
+ headerBlock2 == null);
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock2 local name mismatch",
+ headerBlock2.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.2 Header Test : - HeaderBlock2 namespace uri mismatch",
+ headerBlock2.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ assertTrue(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method twice, getChildren method returns an iterator with more than two elements",
+ iterator.next() == null);
+ }
+
+ public void testSOAP12ExamineHeaderBlocks() {
+ soap12Header.addHeaderBlock("echoOk1", namespace);
+ soap12Header.addHeaderBlock("echoOk2", namespace).setRole(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver");
+ Iterator iterator = soap12Header.examineHeaderBlocks(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlockWithRole = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test : - headerBlockWithRole local name mismatch",
+ headerBlockWithRole.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.2 Header Test : - headerBlockWithRole role value mismatch",
+ headerBlockWithRole.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver"));
+
+ assertFalse(
+ "SOAP 1.2 Header Test : - header has one headerBlock with role, but examineHeaderBlocks(String role) method returns an iterator with more than one object",
+ iterator.hasNext());
+
+ }
+
+
+ public void testSOAP12ExamineMustUnderstandHeaderBlocks() {
+ soap12Header.addHeaderBlock("echoOk1", namespace).setRole(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+
+ SOAPHeaderBlock headerBlock1 = soap12Header.addHeaderBlock("echoOk2",
+ namespace);
+ headerBlock1.setRole(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ headerBlock1.setMustUnderstand(true);
+
+ soap12Header.addHeaderBlock("echoOk3", namespace).setMustUnderstand(
+ true);
+
+ Iterator iterator = soap12Header.examineMustUnderstandHeaderBlocks(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Header Test : - examineMustUnderstandHeaderBlocks method returns empty iterator",
+ headerBlock == null);
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock local name mismatch",
+ headerBlock.getLocalName().equals("echoOk2"));
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock role value mismatch",
+ headerBlock.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ assertFalse(
+ "SOAP 1.2 Header Test : - examineMustUnderstandHeaderBlocks method returns an iterator with more than one object",
+ iterator.hasNext());
+ }
+
+ public void testSOAP12ExamineAllHeaderBlocks() {
+ soap12Header.addHeaderBlock("echoOk1", namespace);
+ soap12Header.addHeaderBlock("echoOk2", namespace);
+ Iterator iterator = soap12Header.examineAllHeaderBlocks();
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns empty iterator",
+ headerBlock1 == null);
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock1 local name mismatch",
+ headerBlock1.getLocalName().equals("echoOk1"));
+ assertTrue(
+ "SOAP 1.2 Header Test : - HeaderBlock1 namespace uri mismatch",
+ headerBlock1.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertFalse(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns an iterator with only one object",
+ headerBlock2 == null);
+ assertTrue("SOAP 1.2 Header Test : - HeaderBlock2 local name mismatch",
+ headerBlock2.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.2 Header Test : - HeaderBlock2 namespace uri mismatch",
+ headerBlock2.getNamespace().getName().equals(
+ "http://www.example.org"));
+
+ assertFalse(
+ "SOAP 1.2 Header Test : - After calling addHeaderBlock method twice, examineAllHeaderBlocks method returns an iterator with more than two object",
+ iterator.hasNext());
+ }
+// public void testSOAP12ExtractAllHeaderBlocks() {
+//
+// }
+
+ public void testSOAP12getHeaderBlocksWithNSURI() {
+ soap12Header.addHeaderBlock("echoOk1", namespace);
+ soap12Header.addHeaderBlock("echoOk2",
+ omFactory.createOMNamespace("http://www.test1.org", "test1"));
+ ArrayList arrayList = soap12Header.getHeaderBlocksWithNSURI(
+ "http://www.test1.org");
+ assertTrue(
+ "SOAP 1.2 Header Test : - getHeaderBlocksWithNSURI returns an arrayList of incorrect size",
+ arrayList.size() == 1);
+ assertTrue(
+ "SOAP 1.2 Header Test : - headerBlock of given namespace uri, mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getNamespace().getName()
+ .equals("http://www.test1.org"));
+ }
+
+ //SOAP 1.1 Header Test (With Parser)---------------------------------------------------------------------------------------------
+ public void testSOAP11ExamineHeaderBlocksWithParser() {
+ Iterator iterator = soap11HeaderWithParser.examineHeaderBlocks(
+ "http://schemas.xmlsoap.org/soap/actor/next");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertEquals(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 localname mismatch",
+ headerBlock1.getLocalName(),
+ "From");
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 role value mismatch",
+ headerBlock1.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/actor/next"));
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock2 localname mmismatch",
+ headerBlock2.getLocalName().equals("MessageID"));
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock2 role value mmismatch",
+ headerBlock2.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/actor/next"));
+
+ assertFalse(
+ "SOAP 1.1 Header Test With Parser : - examineHeaderBlocks(String role) method returns an iterator with more than two objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP11ExamineMustUnderstandHeaderBlocksWithParser() {
+ Iterator iterator = soap11HeaderWithParser.examineMustUnderstandHeaderBlocks(
+ "http://schemas.xmlsoap.org/soap/actor/next");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock1.getLocalName().equals("MessageID"));
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 role value mmismatch",
+ headerBlock1.getRole().equals(
+ "http://schemas.xmlsoap.org/soap/actor/next"));
+
+ assertFalse(
+ "SOAP 1.1 Header Test With Parser : - examineMustUnderstandHeaderBlocks(String role) method returns an iterator with more than one objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP11ExamineAllHeaderBlocksWithParser() {
+ Iterator iterator = soap11HeaderWithParser.examineAllHeaderBlocks();
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock1.getLocalName().equals("From"));
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock2.getLocalName().equals("MessageID"));
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock3 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock3.getLocalName().equals("To"));
+
+ assertFalse(
+ "SOAP 1.1 Header Test With Parser : - examineAllHeaderBlocks method returns an iterator with more than three objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP11getHeaderBlocksWithNSURIWithParser() {
+ ArrayList arrayList = soap11HeaderWithParser.getHeaderBlocksWithNSURI(
+ "http://example.org/ts-tests");
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - getHeaderBlocksWithNSURI returns an arrayList of incorrect size",
+ arrayList.size() == 1);
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock of given namespace uri, local name mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getLocalName().equals(
+ "MessageID"));
+ assertTrue(
+ "SOAP 1.1 Header Test With Parser : - headerBlock of given namespace uri, mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getNamespace().getName()
+ .equals("http://example.org/ts-tests"));
+ }
+
+ //SOAP 1.2 Header Test (With Parser)-------------------------------------------------------------------------------------------
+ public void testSOAP12ExamineHeaderBlocksWithParser() {
+ Iterator iterator = soap12HeaderWithParser.examineHeaderBlocks(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock1.getLocalName().equals("echoOk"));
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock1 role value mmismatch",
+ headerBlock1.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock2 localname mmismatch",
+ headerBlock2.getLocalName().equals("echoOk2"));
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock2 role value mmismatch",
+ headerBlock2.getRole().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+
+ assertFalse(
+ "SOAP 1.2 Header Test With Parser : - examineHeaderBlocks(String role) method returns an iterator with more than two objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP12ExamineMustUnderstandHeaderBlocksWithParser() {
+ Iterator iterator = soap12HeaderWithParser.examineMustUnderstandHeaderBlocks(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertEquals(
+ "SOAP 1.2 Header Test With Parser : - headerBlock localname mmismatch",
+ headerBlock1.getLocalName(),
+ "echoOk");
+ assertEquals(
+ "SOAP 1.2 Header Test With Parser : - headerBlock role value mmismatch",
+ headerBlock1.getRole(),
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+
+ iterator.hasNext();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertEquals(
+ "SOAP 1.2 Header Test With Parser : - headerBlock localname mmismatch",
+ headerBlock2.getLocalName(),
+ "echoOk2");
+ assertEquals(
+ "SOAP 1.2 Header Test With Parser : - headerBlock role value mmismatch",
+ headerBlock1.getRole(),
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver");
+
+ assertFalse(
+ "SOAP 1.2 Header Test With Parser : - examineMustUnderstandHeaderBlocks(String role) method returns an iterator with more than one objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP12ExamineAllHeaderBlocksWithParser() {
+ Iterator iterator = soap12HeaderWithParser.examineAllHeaderBlocks();
+ iterator.next();
+ SOAPHeaderBlock headerBlock1 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock1.getLocalName().equals("echoOk"));
+ iterator.next();
+ SOAPHeaderBlock headerBlock2 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock2.getLocalName().equals("echoOk1"));
+ iterator.next();
+ SOAPHeaderBlock headerBlock3 = (SOAPHeaderBlock) iterator.next();
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock1 localname mmismatch",
+ headerBlock3.getLocalName().equals("echoOk2"));
+
+ assertFalse(
+ "SOAP 1.2 Header Test With Parser : - examineAllHeaderBlocks method returns an iterator with more than three objects",
+ iterator.hasNext());
+ }
+
+ public void testSOAP12getHeaderBlocksWithNSURIWithParser() {
+ ArrayList arrayList = soap12HeaderWithParser.getHeaderBlocksWithNSURI(
+ "http://example.org/ts-tests");
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - getHeaderBlocksWithNSURI returns an arrayList of incorrect size",
+ arrayList.size() == 1);
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock of given namespace uri, local name mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getLocalName().equals(
+ "echoOk"));
+ assertTrue(
+ "SOAP 1.2 Header Test With Parser : - headerBlock of given namespace uri, mismatch",
+ ((SOAPHeaderBlock) arrayList.get(0)).getNamespace().getName()
+ .equals("http://example.org/ts-tests"));
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPHeaderTestCase.java b/test/org/apache/ws/commons/soap/SOAPHeaderTestCase.java
new file mode 100644
index 0000000..1f86efb
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPHeaderTestCase.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMNamespace;
+
+public class SOAPHeaderTestCase extends SOAPTestCase {
+ protected SOAPHeader soap11Header;
+ protected SOAPHeader soap12Header;
+ protected SOAPHeader soap11HeaderWithParser;
+ protected SOAPHeader soap12HeaderWithParser;
+ protected OMNamespace namespace;
+
+ public SOAPHeaderTestCase(String testName) {
+ super(testName);
+ namespace =
+ omFactory.createOMNamespace("http://www.example.org", "test");
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soap11Header = soap11Factory.createSOAPHeader(soap11Envelope);
+ soap12Header = soap12Factory.createSOAPHeader(soap12Envelope);
+ soap11HeaderWithParser = soap11EnvelopeWithParser.getHeader();
+ soap12HeaderWithParser = soap12EnvelopeWithParser.getHeader();
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPMessageTest.java b/test/org/apache/ws/commons/soap/SOAPMessageTest.java
new file mode 100644
index 0000000..192d596
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPMessageTest.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+public class SOAPMessageTest extends OMTestCase {
+
+ public SOAPMessageTest(String testName) {
+ super(testName);
+ }
+
+ public void testSOAPMessageCreation(){
+ try {
+ StAXSOAPModelBuilder soapBuilder = getOMBuilder("");
+ SOAPMessage soapMessage = soapBuilder.getSoapMessage();
+ assertNotNull(soapMessage);
+ assertNotNull(soapMessage.getSOAPEnvelope());
+ } catch (Exception e) {
+ fail("Exception thrown "+ e);
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/SOAPTestCase.java b/test/org/apache/ws/commons/soap/SOAPTestCase.java
new file mode 100644
index 0000000..41845f2
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/SOAPTestCase.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import org.apache.ws.commons.om.AbstractTestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+
+public class SOAPTestCase extends AbstractTestCase {
+ protected SOAPFactory soap11Factory;
+ protected SOAPFactory soap12Factory;
+ protected OMFactory omFactory;
+
+ protected SOAPEnvelope soap11Envelope;
+ protected SOAPEnvelope soap12Envelope;
+
+ protected SOAPEnvelope soap11EnvelopeWithParser;
+ protected SOAPEnvelope soap12EnvelopeWithParser;
+
+ protected static final String SOAP11_FILE_NAME = "soap/soap11/soap11message.xml";
+ protected static final String SOAP12_FILE_NAME = "soap/soap12message.xml";
+ private Log log = LogFactory.getLog(getClass());
+ /**
+ * @param testName
+ */
+ public SOAPTestCase(String testName) {
+ super(testName);
+ soap11Factory = OMAbstractFactory.getSOAP11Factory();
+ soap12Factory = OMAbstractFactory.getSOAP12Factory();
+ omFactory = OMAbstractFactory.getOMFactory();
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+
+ soap11Envelope = soap11Factory.createSOAPEnvelope();
+ soap12Envelope = soap12Factory.createSOAPEnvelope();
+
+ soap11EnvelopeWithParser =
+ (SOAPEnvelope) this.getSOAPBuilder(SOAP11_FILE_NAME)
+ .getDocumentElement();
+ soap12EnvelopeWithParser =
+ (SOAPEnvelope) this.getSOAPBuilder(SOAP12_FILE_NAME)
+ .getDocumentElement();
+ }
+
+ protected StAXSOAPModelBuilder getSOAPBuilder(String fileName) {
+ XMLStreamReader parser = null;
+ try {
+ parser =
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new FileReader(getTestResourceFile(fileName)));
+ } catch (XMLStreamException e) {
+ log.info(e.getMessage());
+ } catch (FileNotFoundException e) {
+ log.info(e.getMessage());
+ }
+ return new StAXSOAPModelBuilder(parser, null);
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/WrongEnvelopeNamespaceTester.java b/test/org/apache/ws/commons/soap/WrongEnvelopeNamespaceTester.java
new file mode 100644
index 0000000..b987625
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/WrongEnvelopeNamespaceTester.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.impl.llom.builder.StAXBuilder;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public class WrongEnvelopeNamespaceTester extends TestCase {
+ public void testCode() {
+ try {
+ String filename = "test-resources/soap/wrongEnvelopeNamespace.xml";
+ XMLStreamReader xmlr = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new FileInputStream(filename));
+ StAXBuilder builder = new StAXSOAPModelBuilder(xmlr, null); //exception here
+ fail("Builder must fail here due to wrong SOAP namespace");
+ } catch (SOAPProcessingException e) {
+ assertTrue(true);
+ } catch (FileNotFoundException e) {
+ fail("Only SOAPProcessingException can be thrown here");
+ }catch (Exception e) {
+ fail("Only SOAPProcessingException can be thrown here");
+ }
+ }
+
+ public static void main(String[] args) {
+ WrongEnvelopeNamespaceTester tester = new WrongEnvelopeNamespaceTester();
+ tester.testCode();
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/CharacterEncodingTest.java b/test/org/apache/ws/commons/soap/impl/llom/CharacterEncodingTest.java
new file mode 100644
index 0000000..66f4778
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/CharacterEncodingTest.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMOutputFormat;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFactory;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.FactoryConfigurationError;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+
+/**
+ * Test for serialization and deserialization using UTF-16
+ * character encoding
+ */
+public class CharacterEncodingTest extends TestCase {
+
+ public static final String UTF_16 = "utf-16";
+
+ public CharacterEncodingTest(String name) {
+ super(name);
+ }
+
+ public void runTest(String value, String expected) throws XMLStreamException, FactoryConfigurationError, IOException {
+
+ SOAPFactory factory = OMAbstractFactory.getSOAP12Factory();
+ SOAPEnvelope envelope = factory.getDefaultEnvelope();
+ String ns = "http://testuri.org";
+ OMNamespace namespace = factory.createOMNamespace(ns,"tst");
+
+ String ln = "Child";
+
+ OMElement bodyChild = factory.createOMElement(ln,namespace);
+ bodyChild.addChild(factory.createText(value));
+
+ envelope.getBody().addChild(bodyChild);
+
+
+ ByteArrayOutputStream byteOutStr = new ByteArrayOutputStream();
+
+ OMOutputFormat outputFormat = new OMOutputFormat();
+ outputFormat.setCharSetEncoding(UTF_16);
+ envelope.serialize(byteOutStr, outputFormat);
+
+ ByteArrayInputStream byteInStr = new ByteArrayInputStream(byteOutStr.toByteArray());
+
+ StAXSOAPModelBuilder builder = new StAXSOAPModelBuilder(XMLInputFactory.newInstance().createXMLStreamReader(byteInStr, UTF_16),null);
+
+ SOAPEnvelope resultEnv = builder.getSOAPEnvelope();
+
+ OMElement bodyChildResult = resultEnv.getBody().getFirstElement();
+
+ assertNotNull("No child in body element", bodyChildResult);
+
+ String result = bodyChildResult.getText();
+
+ assertNotNull("No value for testParam param", result);
+
+ assertEquals("Expected result not received.", expected, result);
+
+
+ }
+
+ private void runtest(String value) throws Exception {
+ runTest(value, value);
+ }
+
+ public void testSimpleString() throws Exception {
+ runtest("a simple string");
+ }
+
+ public void testStringWithApostrophes() throws Exception {
+ runtest("this isn't a simple string");
+ }
+
+ public void testStringWithEntities() throws Exception {
+ runTest("&<>'"", "&<>'"");
+ }
+
+ public void testStringWithRawEntities() throws Exception {
+ runTest("&<>'\"", "&<>'\"");
+ }
+ public void testStringWithLeadingAndTrailingSpaces() throws Exception {
+ runtest(" centered ");
+ }
+
+ public void testWhitespace() throws Exception {
+ runtest(" \n \t "); // note: \r fails
+ }
+
+ public void testFrenchAccents() throws Exception {
+ runtest("\u00e0\u00e2\u00e4\u00e7\u00e8\u00e9\u00ea\u00eb\u00ee\u00ef\u00f4\u00f6\u00f9\u00fb\u00fc");
+ }
+
+ public void testGermanUmlauts() throws Exception {
+ runtest(" Some text \u00df with \u00fc special \u00f6 chars \u00e4.");
+ }
+
+ public void testWelcomeUnicode() throws Exception {
+ // welcome in several languages
+ runtest(
+ "Chinese (trad.) : \u6b61\u8fce ");
+ }
+
+ public void testWelcomeUnicode2() throws Exception {
+ // welcome in several languages
+ runtest(
+ "Greek : \u03ba\u03b1\u03bb\u03ce\u03c2 \u03bf\u03c1\u03af\u03c3\u03b1\u03c4\u03b5");
+ }
+
+ public void testWelcomeUnicode3() throws Exception {
+ // welcome in several languages
+ runtest(
+ "Japanese : \u3088\u3046\u3053\u305d");
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/OMElementTest.java b/test/org/apache/ws/commons/soap/impl/llom/OMElementTest.java
new file mode 100644
index 0000000..57a3066
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/OMElementTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMConstants;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMFactory;
+import org.apache.ws.commons.om.OMNamespace;
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.om.OMText;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.namespace.QName;
+import java.util.Iterator;
+
+public class OMElementTest extends OMTestCase implements OMConstants {
+ private static final String WSA_URI = "http://schemas.xmlsoap.org/ws/2004/03/addressing";
+ private static final String WSA_TO = "To";
+ private Log log = LogFactory.getLog(getClass());
+
+ OMFactory factory = OMAbstractFactory.getOMFactory();
+ private OMElement firstElement;
+ private OMElement secondElement;
+
+
+ public OMElementTest(String testName) {
+ super(testName);
+ }
+
+ /*
+ * @see TestCase#setUp()
+ */
+ protected void setUp() throws Exception {
+ OMNamespace testingNamespace = factory.createOMNamespace(
+ "http://testing.ws.org", "ws");
+ firstElement = factory.createOMElement("FirstElement", testingNamespace);
+ secondElement = factory.createOMElement("SecondElement", factory.createOMNamespace(
+ "http://moretesting.ws.org", "ws"), firstElement);
+ }
+
+ public void testGetText() {
+ try {
+ StAXSOAPModelBuilder soapBuilder = getOMBuilder(
+ "soap/OMElementTest.xml");
+ SOAPEnvelope soapEnvelope = (SOAPEnvelope) soapBuilder.getDocumentElement();
+ OMElement wsaTo = soapEnvelope.getHeader().getFirstChildWithName(
+ new QName(WSA_URI, WSA_TO));
+
+ String expectedString = "http://localhost:8081/axis/services/BankPort";
+ assertEquals("getText is not returning the correct value",
+ wsaTo.getText().trim(),
+ expectedString);
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ }
+ }
+
+ public void testConstructors(){
+
+ try {
+ factory.createOMElement("", null);
+ fail("This should fail as OMElement should not be allowed to create without a local name ");
+ } catch (Exception e) {
+ assertTrue(true);
+ }
+
+ assertTrue("Namespace having same information, declared in the same context, should share" +
+ " the same namespace object",firstElement.getNamespace() != secondElement.getNamespace());
+ assertEquals("OMElement children addition has not worked properly", secondElement, firstElement.getFirstElement());
+
+ OMNamespace testNamespace2 = factory.createOMNamespace("ftp://anotherTest.ws.org", "ws");
+ firstElement.declareNamespace(testNamespace2);
+
+ OMNamespace inheritedSecondNamespace = secondElement.findNamespace(testNamespace2.getName(),
+ testNamespace2.getPrefix());
+ assertNotNull("Children should inherit namespaces declared in parent", inheritedSecondNamespace);
+ assertEquals("inherited namespace uri should be equal", inheritedSecondNamespace.getName(), testNamespace2.getName());
+ assertEquals("inherited namespace prefix should be equal", inheritedSecondNamespace.getPrefix(), testNamespace2.getPrefix());
+
+
+ }
+
+ public void testChildDetachment() {
+ OMNamespace testNamespace2 = factory.createOMNamespace("ftp://anotherTest.ws.org", "ws");
+
+ secondElement.detach();
+ assertTrue("OMElement children detachment has not worked properly", !secondElement.equals(firstElement.getFirstElement()));
+ assertNull("First Element should not contain elements after detaching. ", firstElement.getFirstElement());
+ assertNull("First Element should not contain elements after detaching. ", firstElement.getFirstOMChild());
+ assertNull(secondElement.findNamespace(testNamespace2.getName(), testNamespace2.getPrefix()));
+
+ firstElement.addChild(secondElement);
+ firstElement.setText("Some Sample Text");
+
+ assertTrue("First added child must be the first child", secondElement.equals(firstElement.getFirstOMChild()));
+ Iterator children = firstElement.getChildren();
+ int childCount = 0;
+ while (children.hasNext()) {
+ children.next();
+ childCount++;
+ }
+ assertEquals("Children count should be two", childCount, 2);
+
+ secondElement.detach();
+ assertTrue("First child should be the text child", firstElement.getFirstOMChild() instanceof OMText);
+
+
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/OMEnvelopeTest.java b/test/org/apache/ws/commons/soap/impl/llom/OMEnvelopeTest.java
new file mode 100644
index 0000000..c1886ec
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/OMEnvelopeTest.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMAbstractFactory;
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.om.OMTestUtils;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPProcessingException;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class OMEnvelopeTest extends OMTestCase {
+ private Log log = LogFactory.getLog(getClass());
+ public OMEnvelopeTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ }
+
+ public void testGetHeader1() {
+ SOAPHeader header = soapEnvelope.getHeader();
+ assertTrue("Header information retrieved not correct",
+ (header != null &&
+ header.getLocalName().equalsIgnoreCase("Header")));
+ }
+
+ public void testGetBody1() {
+ SOAPBody body = soapEnvelope.getBody();
+ assertTrue("Header information retrieved not correct",
+ (body != null && body.getLocalName().equalsIgnoreCase("Body")));
+ }
+
+ private SOAPEnvelope getSecondEnvelope() throws Exception {
+ return (SOAPEnvelope) OMTestUtils.getOMBuilder(
+ getTestResourceFile("soap/sample1.xml"))
+ .getDocumentElement();
+ }
+
+ public void testGetHeader2() throws Exception {
+ SOAPHeader header = getSecondEnvelope().getHeader();
+ assertTrue("Header information retrieved not correct",
+ (header != null &&
+ header.getLocalName().equalsIgnoreCase("Header")));
+ }
+
+ public void testGetBody2() throws Exception {
+ SOAPBody body = getSecondEnvelope().getBody();
+ assertTrue("Header information retrieved not correct",
+ (body != null && body.getLocalName().equalsIgnoreCase("Body")));
+ }
+
+ public void testDefaultEnveleope() {
+ SOAPEnvelope env = null;
+ try {
+ env = OMAbstractFactory.getSOAP11Factory().getDefaultEnvelope();
+ } catch (SOAPProcessingException e) {
+ log.info(e.getMessage());
+ fail(e.getMessage());
+ }
+ assertNotNull(env);
+ assertNotNull("Body should not be null", env.getBody());
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/OMHeaderBlockTest.java b/test/org/apache/ws/commons/soap/impl/llom/OMHeaderBlockTest.java
new file mode 100644
index 0000000..ffbdfcb
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/OMHeaderBlockTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+
+import java.util.Iterator;
+
+public class OMHeaderBlockTest extends OMTestCase {
+ SOAPHeader soapHeader;
+ SOAPHeaderBlock soapHeaderElement;
+
+ public OMHeaderBlockTest(String testName) {
+ super(testName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soapHeader = soapEnvelope.getHeader();
+ Iterator headerElementIter = soapHeader.examineAllHeaderBlocks();
+ if (headerElementIter.hasNext()) {
+ soapHeaderElement = (SOAPHeaderBlock) headerElementIter.next();
+ }
+ }
+
+ public void testSetAndGetActor() {
+ String newActorURI = "http://newActor.org";
+ soapHeaderElement.setRole(newActorURI);
+ assertTrue("Actor was not properly set",
+ soapHeaderElement.getRole().equalsIgnoreCase(newActorURI));
+ }
+
+ public void testSetAndGetMustUnderstand() {
+ soapHeaderElement.setMustUnderstand(false);
+ assertTrue("MustUnderstand was not properly set",
+ !soapHeaderElement.getMustUnderstand());
+ }
+
+ public void testGetMustUnderstand() {
+ //TODO Implement getMustUnderstand().
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/OMHeaderTest.java b/test/org/apache/ws/commons/soap/impl/llom/OMHeaderTest.java
new file mode 100644
index 0000000..2cc86e4
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/OMHeaderTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom;
+
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.om.impl.llom.OMNamespaceImpl;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+
+import java.util.Iterator;
+
+public class OMHeaderTest extends OMTestCase {
+ SOAPHeader soapHeader;
+
+ public OMHeaderTest(String testName) {
+ super(testName);
+ }
+
+ public static void main(String[] args) {
+ }
+
+ /*
+ * @see TestCase#setUp()
+ */
+ protected void setUp() throws Exception {
+ super.setUp();
+ soapHeader = soapEnvelope.getHeader();
+ }
+
+ public void testAddHeaderElement() {
+ String newElementName = "MyHeaderElement";
+ SOAPHeaderBlock soapHeaderElement = soapHeader.addHeaderBlock(
+ newElementName,
+ new OMNamespaceImpl("http://opensource.lk", "lsf"));
+ assertTrue(
+ "Header Element added has different parent than it should have",
+ soapHeaderElement.getParent() == soapHeader);
+ assertTrue(
+ "Header Element added has different localname than it was given",
+ soapHeaderElement.getLocalName().equalsIgnoreCase(
+ newElementName));
+ }
+
+ public void testExamineHeaderElements() {
+ }
+
+ public void testExtractHeaderElements() {
+ //TODO Implement extractHeaderBlocks().
+ }
+
+ public void testExamineMustUnderstandHeaderElements() {
+ //TODO Implement examineMustUnderstandHeaderBlocks().
+ }
+
+ public void testExamineAllHeaderElements() {
+ Iterator iterator = soapHeader.examineAllHeaderBlocks();
+ int headerElementCount = 0;
+ while (iterator.hasNext()) {
+ iterator.next();
+ headerElementCount++;
+ }
+ assertTrue(
+ "Number of header elements in the header differs from expected value of 3",
+ headerElementCount == 3);
+ }
+
+ public void testExtractAllHeaderElements() {
+ //TODO Implement extractAllHeaderBlocks().
+ }
+
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilderTest.java b/test/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilderTest.java
new file mode 100644
index 0000000..2a12e96
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/builder/StAXSOAPModelBuilderTest.java
@@ -0,0 +1,560 @@
+package org.apache.ws.commons.soap.impl.llom.builder;
+
+import junit.framework.TestCase;
+import org.apache.ws.commons.om.OMAttribute;
+import org.apache.ws.commons.om.OMElement;
+import org.apache.ws.commons.om.OMXMLParserWrapper;
+import org.apache.ws.commons.soap.SOAP11Constants;
+import org.apache.ws.commons.soap.SOAP12Constants;
+import org.apache.ws.commons.soap.SOAPBody;
+import org.apache.ws.commons.soap.SOAPConstants;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.SOAPFault;
+import org.apache.ws.commons.soap.SOAPFaultCode;
+import org.apache.ws.commons.soap.SOAPFaultDetail;
+import org.apache.ws.commons.soap.SOAPFaultNode;
+import org.apache.ws.commons.soap.SOAPFaultReason;
+import org.apache.ws.commons.soap.SOAPFaultRole;
+import org.apache.ws.commons.soap.SOAPFaultSubCode;
+import org.apache.ws.commons.soap.SOAPFaultText;
+import org.apache.ws.commons.soap.SOAPFaultValue;
+import org.apache.ws.commons.soap.SOAPHeader;
+import org.apache.ws.commons.soap.SOAPHeaderBlock;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.StringReader;
+import java.util.Iterator;
+
+public class StAXSOAPModelBuilderTest extends TestCase {
+
+ private Log log = LogFactory.getLog(getClass());
+ public void setUp() {
+
+ }
+
+ public void testStAXSOAPModelBuilder() {
+ String soap12Message =
+ "<env:Envelope xmlns:env=\"http://www.w3.org/2003/05/soap-envelope\">\n" +
+ " <env:Header>\n" +
+ " <test:echoOk xmlns:test=\"http://example.org/ts-tests\"\n" +
+ " env:role=\"http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver\"\n" +
+ " env:mustUnderstand=\"true\">\n" +
+ " foo\n" +
+ " </test:echoOk>\n" +
+ " </env:Header>\n" +
+ " <env:Body>\n" +
+ " <env:Fault>\n" +
+ " <env:Code>\n" +
+ " <env:Value>env:Sender</env:Value>\n" +
+ " <env:Subcode>\n" +
+ " <env:Value>m:MessageTimeout</env:Value>\n" +
+ " <env:Subcode>\n" +
+ " <env:Value>m:MessageTimeout</env:Value>\n" +
+ " </env:Subcode>\n" +
+ " </env:Subcode>\n" +
+ " </env:Code>\n" +
+ " <env:Reason>\n" +
+ " <env:Text>Sender Timeout</env:Text>\n" +
+ " </env:Reason>\n" +
+ " <env:Node>\n" +
+ " http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver\n" +
+ " </env:Node>\n" +
+ " <env:Role>\n" +
+ " ultimateReceiver\n" +
+ " </env:Role>\n" +
+ " <env:Detail xmlns:m=\"http:www.sample.org\">\n" +
+ " Details of error\n" +
+ " <m:MaxTime m:detail=\"This is only a test\">\n" +
+ " P5M\n" +
+ " </m:MaxTime>\n" +
+ " <m:AveTime>\n" +
+ " <m:Time>\n" +
+ " P3M\n" +
+ " </m:Time>\n" +
+ " </m:AveTime>\n" +
+ " </env:Detail>\n" +
+ " </env:Fault>\n" +
+ " </env:Body>\n" +
+ "</env:Envelope>";
+
+ String soap11Message =
+ "<?xml version='1.0' ?>" +
+ "<env:Envelope xmlns:env=\"http://schemas.xmlsoap.org/soap/envelope/\">\n" +
+ " <env:Header>\n" +
+ " <test:echoOk xmlns:test=\"http://example.org/ts-tests\"\n" +
+ " env:actor=\"http://schemas.xmlsoap.org/soap/actor/next\"\n" +
+ " env:mustUnderstand=\"1\"" +
+ " >\n" +
+ " foo\n" +
+ " </test:echoOk>\n" +
+ " </env:Header>\n" +
+ " <env:Body>\n" +
+ " <env:Fault>\n" +
+ " <env:faultcode>\n" +
+ " env:Sender\n" +
+ " </env:faultcode>\n" +
+ " <env:faultstring>\n" +
+ " Sender Timeout\n" +
+ " </env:faultstring>\n" +
+ " <env:faultactor>\n" +
+ " http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver\n" +
+ " </env:faultactor>\n" +
+ " <env:detail xmlns:m=\"http:www.sample.org\">\n" +
+ " Details of error\n" +
+ " <m:MaxTime m:detail=\"This is only a test\">\n" +
+ " P5M\n" +
+ " </m:MaxTime>\n" +
+ " <m:AveTime>\n" +
+ " <m:Time>\n" +
+ " P3M\n" +
+ " </m:Time>\n" +
+ " </m:AveTime>\n" +
+ " </env:detail>\n" +
+ " <n:Test xmlns:n=\"http:www.Test.org\">\n" +
+ " <n:TestElement>\n" +
+ " This is only a test\n" +
+ " </n:TestElement>\n" +
+ " </n:Test>\n" +
+ " </env:Fault>\n" +
+ " </env:Body>\n" +
+ "</env:Envelope>";
+
+
+ try {
+ XMLStreamReader sopa12Parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new StringReader(soap12Message));
+ OMXMLParserWrapper soap12Builder = new StAXSOAPModelBuilder(sopa12Parser, null);
+ SOAPEnvelope soap12Envelope = (SOAPEnvelope) soap12Builder.getDocumentElement();
+// soap12Envelope.build();
+// XMLStreamWriter writer = XMLOutputFactory.newInstance().createXMLStreamWriter(System.out);
+// soap12Envelope.serializeAndConsume(writer);
+// writer.flush();
+
+ assertTrue("SOAP 1.2 :- envelope local name mismatch",
+ soap12Envelope.getLocalName().equals(
+ SOAPConstants.SOAPENVELOPE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- envelope namespace uri mismatch",
+ soap12Envelope.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ SOAPHeader header = soap12Envelope.getHeader();
+ assertTrue("SOAP 1.2 :- Header local name mismatch",
+ header.getLocalName().equals(
+ SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Header namespace uri mismatch",
+ header.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ SOAPHeaderBlock headerBlock = (SOAPHeaderBlock) header.getFirstElement();
+ assertTrue("SOAP 1.2 :- Header block name mismatch",
+ headerBlock.getLocalName().equals("echoOk"));
+ assertTrue("SOAP 1.2 :- Header block name space uri mismatch",
+ headerBlock.getNamespace().getName().equals(
+ "http://example.org/ts-tests"));
+ assertEquals("SOAP 1.2 :- Header block text mismatch",headerBlock.getText().trim(),"foo");
+
+ Iterator headerBlockAttributes = headerBlock.getAllAttributes();
+ OMAttribute roleAttribute = (OMAttribute) headerBlockAttributes.next();
+ assertTrue("SOAP 1.2 :- Role attribute name mismatch",
+ roleAttribute.getLocalName().equals(
+ SOAP12Constants.SOAP_ROLE));
+
+
+ assertTrue("SOAP 1.2 :- Role value mismatch",
+ roleAttribute.getAttributeValue().trim().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI + "/" +
+ SOAP12Constants.SOAP_ROLE +
+ "/" +
+ "ultimateReceiver"));
+ assertTrue("SOAP 1.2 :- Role attribute namespace uri mismatch",
+ roleAttribute.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ OMAttribute mustUnderstandAttribute = (OMAttribute) headerBlockAttributes.next();
+ assertTrue("SOAP 1.2 :- Mustunderstand attribute name mismatch",
+ mustUnderstandAttribute.getLocalName().equals(
+ SOAPConstants.ATTR_MUSTUNDERSTAND));
+ assertTrue("SOAP 1.2 :- Mustunderstand value mismatch",
+ mustUnderstandAttribute.getAttributeValue().equals(
+ SOAPConstants.ATTR_MUSTUNDERSTAND_TRUE));
+ assertTrue(
+ "SOAP 1.2 :- Mustunderstand attribute namespace uri mismatch",
+ mustUnderstandAttribute.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ SOAPBody body = soap12Envelope.getBody();
+ assertTrue("SOAP 1.2 :- Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Body namespace uri mismatch",
+ body.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ SOAPFault fault = body.getFault();
+ assertTrue("SOAP 1.2 :- Fault local name mismatch",
+ fault.getLocalName().equals(
+ SOAPConstants.SOAPFAULT_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault namespace uri mismatch",
+ fault.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ Iterator iteratorInFault = fault.getChildren();
+
+ iteratorInFault.next();
+ SOAPFaultCode code = (SOAPFaultCode) iteratorInFault.next();
+ assertTrue("SOAP 1.2 :- Fault code local name mismatch",
+ code.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault code namespace uri mismatch",
+ code.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ Iterator iteratorInCode = code.getChildren();
+
+ iteratorInCode.next();
+ SOAPFaultValue value1 = (SOAPFaultValue) iteratorInCode.next();
+ assertTrue("SOAP 1.2 :- Fault code value local name mismatch",
+ value1.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault code namespace uri mismatch",
+ value1.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Value1 text mismatch",
+ value1.getText().equals("env:Sender"));
+
+ iteratorInCode.next();
+ SOAPFaultSubCode subCode1 = (SOAPFaultSubCode) iteratorInCode.next();
+ assertTrue("SOAP 1.2 :- Fault sub code local name mismatch",
+ subCode1.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault subcode namespace uri mismatch",
+ subCode1.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ Iterator iteratorInSubCode1 = subCode1.getChildren();
+
+ iteratorInSubCode1.next();
+ SOAPFaultValue value2 = (SOAPFaultValue) iteratorInSubCode1.next();
+ assertTrue("SOAP 1.2 :- Fault code value local name mismatch",
+ value2.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault code namespace uri mismatch",
+ value2.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Value2 text mismatch",
+ value2.getText().equals("m:MessageTimeout"));
+
+ iteratorInSubCode1.next();
+ SOAPFaultSubCode subCode2 = (SOAPFaultSubCode) iteratorInSubCode1.next();
+ assertTrue("SOAP 1.2 :- Fault sub code local name mismatch",
+ subCode2.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_SUB_CODE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault subcode namespace uri mismatch",
+ subCode2.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ Iterator iteratorInSubCode2 = subCode2.getChildren();
+
+ iteratorInSubCode2.next();
+ SOAPFaultValue value3 = (SOAPFaultValue) iteratorInSubCode2.next();
+ assertTrue("SOAP 1.2 :- Fault code value local name mismatch",
+ value3.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_VALUE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault code namespace uri mismatch",
+ value3.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Value2 text mismatch",
+ value3.getText().equals("m:MessageTimeout"));
+
+ iteratorInFault.next();
+ SOAPFaultReason reason = (SOAPFaultReason) iteratorInFault.next();
+ assertTrue("SOAP 1.2 :- Fault reason local name mismatch",
+ reason.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault reason namespace uri mismatch",
+ reason.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ Iterator iteratorInReason = reason.getChildren();
+
+ iteratorInReason.next();
+ SOAPFaultText text = (SOAPFaultText) iteratorInReason.next();
+ assertTrue("SOAP 1.2 :- Fault text local name mismatch",
+ text.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_TEXT_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Text namespace uri mismatch",
+ text.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Text value mismatch",
+ text.getText().equals("Sender Timeout"));
+
+ iteratorInFault.next();
+ SOAPFaultNode node = (SOAPFaultNode) iteratorInFault.next();
+ assertTrue("SOAP 1.2 :- Fault node local name mismatch",
+ node.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_NODE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault node namespace uri mismatch",
+ node.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Node value mismatch",
+ node.getText().trim().equals(
+ "http://www.w3.org/2003/05/soap-envelope/role/ultimateReceiver"));
+
+ iteratorInFault.next();
+ SOAPFaultRole role = (SOAPFaultRole) iteratorInFault.next();
+ assertTrue("SOAP 1.2 :- Fault role local name mismatch",
+ role.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault role namespace uri mismatch",
+ role.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Role value mismatch",
+ role.getText().trim().equals("ultimateReceiver"));
+
+ iteratorInFault.next();
+ SOAPFaultDetail detail = (SOAPFaultDetail) iteratorInFault.next();
+ assertTrue("SOAP 1.2 :- Fault detail local name mismatch",
+ detail.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault detail namespace uri mismatch",
+ detail.getNamespace().getName().equals(
+ SOAP12Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ assertTrue("SOAP 1.2 :- Text in detail mismatch",
+ detail.getText().trim().equals("Details of error"));
+
+ Iterator iteratorInDetail = detail.getChildren();
+
+ iteratorInDetail.next();
+ OMElement element1 = (OMElement) iteratorInDetail.next();
+ assertTrue("SOAP 1.2 :- MaxTime element mismatch",
+ element1.getLocalName().equals("MaxTime"));
+ assertTrue("SOAP 1.2 :- MaxTime element namespace mismatch",
+ element1.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.2 :- Text value in MaxTime element mismatch",
+ element1.getText().trim().equals("P5M"));
+
+ Iterator attributeIterator = element1.getAllAttributes();
+ OMAttribute attributeInMaxTime = (OMAttribute) attributeIterator.next();
+ assertTrue("SOAP 1.2 :- Attribute local name mismatch",
+ attributeInMaxTime.getLocalName().equals("detail"));
+ assertTrue("SOAP 1.2 :- Attribute namespace mismatch",
+ attributeInMaxTime.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.2 :- Attribute value mismatch",
+ attributeInMaxTime.getAttributeValue().trim().equals("This is only a test"));
+
+ iteratorInDetail.next();
+ OMElement element2 = (OMElement) iteratorInDetail.next();
+ assertTrue("SOAP 1.2 :- AveTime element mismatch",
+ element2.getLocalName().equals("AveTime"));
+ assertTrue("SOAP 1.2 :- AveTime element namespace mismatch",
+ element2.getNamespace().getName().equals(
+ "http:www.sample.org"));
+
+ Iterator iteratorInAveTimeElement = element2.getChildren();
+
+ iteratorInAveTimeElement.next();
+ OMElement element21 = (OMElement) iteratorInAveTimeElement.next();
+ assertTrue("SOAP 1.2 :- Time element mismatch",
+ element21.getLocalName().equals("Time"));
+ assertTrue("SOAP 1.2 :- Time element namespace mismatch",
+ element21.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.2 :- Text value in Time element mismatch",
+ element21.getText().trim().equals("P3M"));
+
+ XMLStreamReader sopa11Parser = XMLInputFactory.newInstance()
+ .createXMLStreamReader(new StringReader(soap11Message));
+ OMXMLParserWrapper soap11Builder = new StAXSOAPModelBuilder(sopa11Parser, null);
+ SOAPEnvelope soap11Envelope = (SOAPEnvelope) soap11Builder.getDocumentElement();
+// soap11Envelope.build();
+// writer = XMLOutputFactory.newInstance().createXMLStreamWriter(System.out);
+// soap11Envelope.serializeAndConsume(writer);
+// writer.flush();
+
+ assertTrue("SOAP 1.1 :- envelope local name mismatch",
+ soap11Envelope.getLocalName().equals(
+ SOAPConstants.SOAPENVELOPE_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- envelope namespace uri mismatch",
+ soap11Envelope.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ header = soap11Envelope.getHeader();
+ assertTrue("SOAP 1.1 :- Header local name mismatch",
+ header.getLocalName().equals(
+ SOAPConstants.HEADER_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- Header namespace uri mismatch",
+ header.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ headerBlock = (SOAPHeaderBlock) header.getFirstElement();
+ assertTrue("SOAP 1.1 :- Header block name mismatch",
+ headerBlock.getLocalName().equals("echoOk"));
+ assertTrue("SOAP 1.1 :- Header block name space uri mismatch",
+ headerBlock.getNamespace().getName().equals(
+ "http://example.org/ts-tests"));
+ assertTrue("SOAP 1.1 :- Headaer block text mismatch",
+ headerBlock.getText().trim().equals("foo"));
+
+ headerBlockAttributes = headerBlock.getAllAttributes();
+
+ mustUnderstandAttribute =
+ (OMAttribute) headerBlockAttributes.next();
+ assertTrue("SOAP 1.1 :- Mustunderstand attribute name mismatch",
+ mustUnderstandAttribute.getLocalName().equals(
+ SOAPConstants.ATTR_MUSTUNDERSTAND));
+ assertTrue("SOAP 1.1 :- Mustunderstand value mismatch",
+ mustUnderstandAttribute.getAttributeValue().equals(
+ SOAPConstants.ATTR_MUSTUNDERSTAND_1));
+ assertTrue(
+ "SOAP 1.1 :- Mustunderstand attribute namespace uri mismatch",
+ mustUnderstandAttribute.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ OMAttribute actorAttribute = (OMAttribute) headerBlockAttributes.next();
+ assertTrue("SOAP 1.1 :- Actor attribute name mismatch",
+ actorAttribute.getLocalName().equals(
+ SOAP11Constants.ATTR_ACTOR));
+ assertTrue("SOAP 1.1 :- Actor value mismatch",
+ actorAttribute.getAttributeValue().trim().equals(
+ "http://schemas.xmlsoap.org/soap/" +
+ SOAP11Constants.ATTR_ACTOR +
+ "/" +
+ "next"));
+ assertTrue("SOAP 1.1 :- Actor attribute namespace uri mismatch",
+ actorAttribute.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ body = soap11Envelope.getBody();
+ assertTrue("SOAP 1.1 :- Body local name mismatch",
+ body.getLocalName().equals(SOAPConstants.BODY_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- Body namespace uri mismatch",
+ body.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ fault = body.getFault();
+ assertTrue("SOAP 1.1 :- Fault namespace uri mismatch",
+ fault.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+
+ iteratorInFault = fault.getChildren();
+
+ iteratorInFault.next();
+ code = (SOAPFaultCode) iteratorInFault.next();
+ assertEquals("SOAP Fault code local name mismatch",
+ code.getLocalName(),
+ (SOAP12Constants.SOAP_FAULT_CODE_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- Fault code namespace uri mismatch",
+ code.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertEquals("SOAP 1.1 :- Fault code value mismatch", code.getValue().getText().trim(),
+ "env:Sender");
+
+ iteratorInFault.next();
+ reason = (SOAPFaultReason) iteratorInFault.next();
+ assertTrue("SOAP 1.1 :- Fault string local name mismatch",
+ reason.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_REASON_LOCAL_NAME));
+ assertTrue("SOAP 1.2 :- Fault string namespace uri mismatch",
+ reason.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.1 :- Fault string value mismatch",
+ reason.getSOAPText().getText().trim().equals("Sender Timeout"));
+
+ iteratorInFault.next();
+ role = (SOAPFaultRole) iteratorInFault.next();
+ assertTrue("SOAP 1.1 :- Fault actor local name mismatch",
+ role.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_ROLE_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- Fault actor namespace uri mismatch",
+ role.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.1 :- Actor value mismatch",
+ role.getText().trim().equals(
+ "http://schemas.xmlsoap.org/soap/envelope/actor/ultimateReceiver"));
+
+ iteratorInFault.next();
+ detail = (SOAPFaultDetail) iteratorInFault.next();
+ assertTrue("SOAP 1.1 :- Fault detail local name mismatch",
+ detail.getLocalName().equals(
+ SOAP12Constants.SOAP_FAULT_DETAIL_LOCAL_NAME));
+ assertTrue("SOAP 1.1 :- Fault detail namespace uri mismatch",
+ detail.getNamespace().getName().equals(
+ SOAP11Constants.SOAP_ENVELOPE_NAMESPACE_URI));
+ assertTrue("SOAP 1.2 :- Text in detail mismatch",
+ detail.getText().trim().equals("Details of error"));
+
+ iteratorInDetail = detail.getChildren();
+
+ iteratorInDetail.next();
+ element1 = (OMElement) iteratorInDetail.next();
+ assertTrue("SOAP 1.1 :- MaxTime element mismatch",
+ element1.getLocalName().equals("MaxTime"));
+ assertTrue("SOAP 1.1 :- MaxTime element namespace mismatch",
+ element1.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.1 :- Text value in MaxTime element mismatch",
+ element1.getText().trim().equals("P5M"));
+
+ attributeIterator = element1.getAllAttributes();
+ attributeInMaxTime = (OMAttribute) attributeIterator.next();
+ assertTrue("SOAP 1.1 :- Attribute local name mismatch",
+ attributeInMaxTime.getLocalName().equals("detail"));
+ assertTrue("SOAP 1.1 :- Attribute namespace mismatch",
+ attributeInMaxTime.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.1 :- Attribute value mismatch",
+ attributeInMaxTime.getAttributeValue().equals("This is only a test"));
+
+ iteratorInDetail.next();
+ element2 = (OMElement) iteratorInDetail.next();
+ assertTrue("SOAP 1.1 :- AveTime element mismatch",
+ element2.getLocalName().equals("AveTime"));
+ assertTrue("SOAP 1.1 :- AveTime element namespace mismatch",
+ element2.getNamespace().getName().equals(
+ "http:www.sample.org"));
+
+ iteratorInAveTimeElement = element2.getChildren();
+
+ iteratorInAveTimeElement.next();
+ element21 = (OMElement) iteratorInAveTimeElement.next();
+ assertTrue("SOAP 1.1 :- Time element mismatch",
+ element21.getLocalName().equals("Time"));
+ assertTrue("SOAP 1.1 :- Time element namespace mismatch",
+ element21.getNamespace().getName().equals(
+ "http:www.sample.org"));
+ assertTrue("SOAP 1.1 :- Text value in Time element mismatch",
+ element21.getText().trim().equals("P3M"));
+
+ iteratorInFault.next();
+ OMElement testElement = (OMElement) iteratorInFault.next();
+ assertTrue("SOAP 1.1 :- Test element mismatch",
+ testElement.getLocalName().equals("Test"));
+ assertTrue("SOAP 1.1 :- Test element namespace mismatch",
+ testElement.getNamespace().getName().equals(
+ "http:www.Test.org"));
+
+ OMElement childOfTestElement = testElement.getFirstElement();
+ assertTrue("SOAP 1.1 :- Test element child local name mismatch",
+ childOfTestElement.getLocalName().equals("TestElement"));
+ assertTrue("SOAP 1.1 :- Test element child namespace mismatch",
+ childOfTestElement.getNamespace().getName().equals(
+ "http:www.Test.org"));
+ assertTrue("SOAP 1.1 :- Test element child value mismatch",
+ childOfTestElement.getText().trim().equals("This is only a test"));
+
+ } catch (XMLStreamException e) {
+ log.info(e.getMessage());
+ fail("Test failed. Reason -> " + e.getMessage());
+ } catch (Exception e) {
+ log.info(e.getMessage());
+ fail("Test failed. Reason -> " + e.getMessage());
+
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11SerializerTest.java b/test/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11SerializerTest.java
new file mode 100644
index 0000000..0b70a19
--- /dev/null
+++ b/test/org/apache/ws/commons/soap/impl/llom/soap11/SOAP11SerializerTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.soap.impl.llom.soap11;
+
+import org.apache.ws.commons.om.OMTestCase;
+import org.apache.ws.commons.soap.SOAPEnvelope;
+import org.apache.ws.commons.soap.impl.llom.builder.StAXSOAPModelBuilder;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamWriter;
+public class SOAP11SerializerTest extends OMTestCase {
+
+ public SOAP11SerializerTest(String testName) {
+ super(testName);
+ }
+
+ protected StAXSOAPModelBuilder getOMBuilder(String fileName) throws Exception {
+ return super.getOMBuilder(fileName);
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ soapEnvelope =
+ (SOAPEnvelope) getOMBuilder("soap/soap11/soap11fault.xml")
+ .getDocumentElement();
+ }
+
+ public void testSerialize() throws Exception {
+ XMLStreamWriter output = XMLOutputFactory.newInstance().
+ createXMLStreamWriter(System.out);
+ soapEnvelope.serialize(output);
+
+ output = XMLOutputFactory.newInstance().
+ createXMLStreamWriter(System.out);
+ soapEnvelope.serializeAndConsume(output);
+ }
+}
diff --git a/test/org/apache/ws/commons/xpath/AXIOMXPathTest.java b/test/org/apache/ws/commons/xpath/AXIOMXPathTest.java
new file mode 100644
index 0000000..ccae7de
--- /dev/null
+++ b/test/org/apache/ws/commons/xpath/AXIOMXPathTest.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed 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.ws.commons.xpath;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import org.apache.ws.commons.om.impl.llom.builder.StAXOMBuilder;
+import org.apache.ws.commons.om.xpath.DocumentNavigator;
+import org.jaxen.FunctionCallException;
+import org.jaxen.Navigator;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamReader;
+import java.io.FileInputStream;
+
+public class AXIOMXPathTest extends XPathTestBase {
+ public AXIOMXPathTest(String name) {
+ super(name);
+ }
+
+ public static Test suite() {
+ return new TestSuite(AXIOMXPathTest.class);
+ }
+
+ public Navigator getNavigator() {
+ return new DocumentNavigator();
+ }
+
+ public Object getDocument(String uri) throws Exception {
+ try {
+ XMLStreamReader parser =
+ XMLInputFactory.newInstance().createXMLStreamReader(
+ new FileInputStream(uri));
+ StAXOMBuilder builder =
+ new StAXOMBuilder(parser);
+ return builder.getDocumentElement();
+ } catch (Exception e) {
+ throw new FunctionCallException(e);
+ }
+ }
+}
diff --git a/test/org/apache/ws/commons/xpath/XPathTestBase.java b/test/org/apache/ws/commons/xpath/XPathTestBase.java
new file mode 100644
index 0000000..0cf3ec0
--- /dev/null
+++ b/test/org/apache/ws/commons/xpath/XPathTestBase.java
@@ -0,0 +1,1810 @@
+/*
+ * $Header: /home/projects/jaxen/scm/jaxen/src/java/test/org/jaxen/XPathTestBase.java,v 1.36 2005/06/17 13:22:31 elharo Exp $
+ * $Revision: 1.36 $
+ * $Date: 2005/06/17 13:22:31 $
+ *
+ * ====================================================================
+ *
+ * Copyright (C) 2000-2002 bob mcwhirter & James Strachan.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions, and the disclaimer that follows
+ * these conditions in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * 3. The name "Jaxen" must not be used to endorse or promote products
+ * derived from this software without prior written permission. For
+ * written permission, please contact license@jaxen.org.
+ *
+ * 4. Products derived from this software may not be called "Jaxen", nor
+ * may "Jaxen" appear in their name, without prior written permission
+ * from the Jaxen Project Management (pm@jaxen.org).
+ *
+ * In addition, we request (but do not require) that you include in the
+ * end-user documentation provided with the redistribution and/or in the
+ * software itself an acknowledgement equivalent to the following:
+ * "This product includes software developed by the
+ * Jaxen Project (http://www.jaxen.org/)."
+ * Alternatively, the acknowledgment may be graphical using the logos
+ * available at http://www.jaxen.org/
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE Jaxen AUTHORS OR THE PROJECT
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * ====================================================================
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Jaxen Project and was originally
+ * created by bob mcwhirter <bob@werken.com> and
+ * James Strachan <jstrachan@apache.org>. For more information on the
+ * Jaxen Project, please see <http://www.jaxen.org/>.
+ *
+ * $Id: XPathTestBase.java,v 1.36 2005/06/17 13:22:31 elharo Exp $
+ */
+
+
+package org.apache.ws.commons.xpath;
+
+import junit.framework.TestCase;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.jaxen.BaseXPath;
+import org.jaxen.Context;
+import org.jaxen.ContextSupport;
+import org.jaxen.FunctionCallException;
+import org.jaxen.JaxenException;
+import org.jaxen.Navigator;
+import org.jaxen.SimpleNamespaceContext;
+import org.jaxen.SimpleVariableContext;
+import org.jaxen.UnsupportedAxisException;
+import org.jaxen.XPath;
+import org.jaxen.XPathFunctionContext;
+import org.jaxen.function.StringFunction;
+import org.jaxen.pattern.Pattern;
+import org.jaxen.saxpath.helpers.XPathReaderFactory;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public abstract class XPathTestBase extends TestCase
+{
+ protected static String VAR_URI = "http://jaxen.org/test-harness/var";
+ protected static String TESTS_ROOT = "test-resources/";
+ protected static String TESTS_XML = TESTS_ROOT + "xml/test/tests.xml";
+
+ protected static boolean verbose = false;
+ protected static boolean debug = false;
+ private ContextSupport contextSupport;
+ private Log log = LogFactory.getLog(getClass());
+
+ public XPathTestBase(String name)
+ {
+ super(name);
+ }
+
+ public void setUp()
+ {
+ this.contextSupport = null;
+ System.setProperty(XPathReaderFactory.DRIVER_PROPERTY,
+ "");
+ log("-----------------------------");
+ }
+
+ public void log(String text)
+ {
+ log(verbose,
+ text);
+ }
+
+ public void log(boolean actualVerbose,
+ String text)
+ {
+ if (actualVerbose) log.info(text);
+ }
+
+ protected void assertCountXPath(int expectedSize, Object context, String xpathStr) throws JaxenException
+ {
+ assertCountXPath2(expectedSize, context, xpathStr);
+ }
+
+ protected Object assertCountXPath2(int expectedSize, Object context, String xpathStr) throws JaxenException
+ {
+ log(debug,
+ " Select :: " + xpathStr);
+ BaseXPath xpath = new BaseXPath(xpathStr, getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ log(debug,
+ " Expected Size :: " + expectedSize);
+ log(debug,
+ " Result Size :: " + results.size());
+ if (expectedSize != results.size())
+ {
+ log(debug,
+ " ## FAILED");
+ log(debug,
+ " ## xpath: " + xpath + " = " + xpath.debug());
+ Iterator resultIter = results.iterator();
+ while (resultIter.hasNext())
+ {
+ log(debug,
+ " --> " + resultIter.next());
+ }
+ }
+ assertEquals(xpathStr,
+ expectedSize,
+ results.size());
+ if (expectedSize > 0)
+ {
+ return results.get(0);
+ }
+ return null;
+ }
+
+ protected void assertInvalidXPath(Object context, String xpathStr)
+ {
+ try
+ {
+ log(debug,
+ " Select :: " + xpathStr);
+ BaseXPath xpath = new BaseXPath(xpathStr, getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ log(debug,
+ " Result Size :: " + results.size());
+ fail("An exception was expected.");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug,
+ " ## SKIPPED -- Unsupported Axis");
+ }
+ catch (JaxenException e)
+ {
+ log(debug, " Caught expected exception " + e.getMessage());
+ }
+ }
+
+ protected void assertValueOfXPath(String expected, Object context, String xpathStr) throws JaxenException
+ {
+ try
+ {
+ BaseXPath xpath = new BaseXPath(xpathStr, getNavigator());
+ Object node = xpath.evaluate(getContext(context));
+ String result = StringFunction.evaluate(node,
+ getNavigator());
+ log(debug,
+ " Select :: " + xpathStr);
+ log(debug,
+ " Expected :: " + expected);
+ log(debug,
+ " Result :: " + result);
+ if (!expected.equals(result))
+ {
+ log(debug,
+ " ## FAILED");
+ log(debug,
+ " ## xpath: " + xpath + " = " + xpath.debug());
+ }
+ assertEquals(xpathStr,
+ expected,
+ result);
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug,
+ " ## SKIPPED -- Unsupported Axis ");
+ }
+ }
+
+ protected Context getContext(Object contextNode)
+ {
+ Context context = new Context(getContextSupport());
+ List list = new ArrayList(1);
+ list.add(contextNode);
+ context.setNodeSet(list);
+ return context;
+ }
+
+ public ContextSupport getContextSupport()
+ {
+ if (this.contextSupport == null)
+ {
+ this.contextSupport = new ContextSupport(new SimpleNamespaceContext(),
+ XPathFunctionContext.getInstance(),
+ new SimpleVariableContext(),
+ getNavigator());
+ }
+ return this.contextSupport;
+ }
+
+ public abstract Navigator getNavigator();
+
+ public abstract Object getDocument(String url) throws Exception;
+
+ public void testGetNodeType() throws FunctionCallException, UnsupportedAxisException
+ {
+ Navigator nav = getNavigator();
+ Object document = nav.getDocument(TESTS_ROOT + "xml/testNamespaces.xml");
+ int count = 0;
+ Iterator descendantOrSelfAxisIterator = nav.getDescendantOrSelfAxisIterator(document);
+ while (descendantOrSelfAxisIterator.hasNext())
+ {
+ Object node = descendantOrSelfAxisIterator.next();
+ Iterator namespaceAxisIterator = nav.getNamespaceAxisIterator(node);
+ while (namespaceAxisIterator.hasNext())
+ {
+ count++;
+ assertEquals("Node type mismatch", Pattern.NAMESPACE_NODE, nav.getNodeType(namespaceAxisIterator.next()));
+ }
+ }
+ assertEquals(25, count);
+ }
+
+
+ /* test for jaxen-24
+ */
+ public void testid53371() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/jaxen24.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/body/div", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "preceding::*[1]");
+ assertValueOfXPath("span", context, "local-name(preceding::*[1])");
+ }
+ }
+
+ /* jaxen-58
+ */
+ public void testid53391() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/jaxen24.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(0, context, "//preceding::x");
+ assertCountXPath(0, context, "//following::x");
+ assertCountXPath(0, context, "/descendant::*/preceding::x");
+ assertCountXPath(0, context, "/descendant::node()/preceding::x");
+ }
+ }
+
+ /* test for jaxen-3
+ */
+ public void testid53430() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("abd", context, "string()");
+ }
+ }
+
+ public void testid53441() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("abd", context, "string()");
+ }
+ }
+
+ public void testid53452() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root/a", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("a", context, "string()");
+ }
+ }
+
+ public void testid53463() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root/c", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("d", context, "string()");
+ }
+ }
+
+ /* test for jaxen-3
+ */
+ public void testid53482() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/jaxen3.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/Configuration/hostname/attrlist/hostname[. = 'CE-A'] ");
+ }
+ }
+
+ /* parser test cases all of which should fail
+ */
+ public void testid53502() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/numbers.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* repeated xpaths, jaxen-35
+ */
+ assertInvalidXPath(context, "/numbers numbers");
+ /* invalid xpath, jaxen-34
+ */
+ assertInvalidXPath(context, "/a/b[c > d]efg");
+ /* invalid xpath, jaxen-27
+ */
+ assertInvalidXPath(context, "/inv/child::");
+ /* invalid xpath, jaxen-26
+ */
+ assertInvalidXPath(context, "/invoice/@test[abcd");
+ assertInvalidXPath(context, "/invoice/@test[abcd > x");
+ /* unterminated string
+ */
+ assertInvalidXPath(context, "string-length('a");
+ /* various edge cases where code threw no exception
+ */
+ assertInvalidXPath(context, "/descendant::()");
+ assertInvalidXPath(context, "(1 + 1");
+ }
+ }
+
+ /* test cases for the use of underscores in names
+ */
+ public void testid53602() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/underscore.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/root/@a");
+ assertCountXPath(1, context, "/root/@_a");
+ assertCountXPath(1, context, "/root/b");
+ assertCountXPath(1, context, "/root/_b");
+ assertValueOfXPath("1", context, "/root/@a");
+ assertValueOfXPath("2", context, "/root/@_a");
+ assertValueOfXPath("1", context, "/root/b");
+ assertValueOfXPath("2", context, "/root/_b");
+ }
+ }
+
+ /* test cases for the use of = with node-sets
+ */
+ public void testid53662() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("true", context, "/web-app/servlet/servlet-name = 'file'");
+ assertValueOfXPath("true", context, "/web-app/servlet/servlet-name = 'snoop'");
+ }
+ }
+
+ public void testid53685() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/numbers.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("true", context, "/numbers/set/nr = '-3'");
+ assertValueOfXPath("true", context, "/numbers/set/nr = -3");
+ assertValueOfXPath("true", context, "/numbers/set/nr = 24");
+ assertValueOfXPath("true", context, "/numbers/set/nr/@value = '9999'");
+ assertValueOfXPath("true", context, "/numbers/set/nr/@value = 9999.0");
+ assertValueOfXPath("true", context, "/numbers/set/nr/@value = 66");
+ }
+ }
+
+ /* test basic math...
+ */
+ public void testid53733() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/numbers.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("true", context, "(8 * 2 + 1) = 17");
+ assertValueOfXPath("true", context, "(1 + 8 * 2) = 17");
+ assertValueOfXPath("true", context, "(7 - 3 + 1) = 5");
+ assertValueOfXPath("true", context, "(8 - 4 + 5 - 6) = 3");
+ /* left-assoc tests, comments show WRONG evaluation
+ */
+ /* 3 - 2 - 1 != 2
+ */
+ assertValueOfXPath("0", context, "3 - 2 - 1");
+ /* 8 div 4 div 2 != 4
+ */
+ assertValueOfXPath("1", context, "8 div 4 div 2");
+ /* 3 mod 5 mod 7 != 1
+ */
+ assertValueOfXPath("3", context, "3 mod 7 mod 5");
+ /* 1=(2=2) is true
+ */
+ assertValueOfXPath("false", context, "1 = 2 = 2");
+ /* 2!=(3!=1) => 2!=1 => true, (2!=3)!=1 => 1!=1 => false
+ */
+ assertValueOfXPath("false", context, "2 != 3 != 1");
+ /* 3 > (2 > 1) is true
+ */
+ assertValueOfXPath("false", context, "3 > 2 > 1");
+ /* 3 >= (2 >= 2) is true
+ */
+ assertValueOfXPath("false", context, "3 >= 2 >= 2");
+ /* 1 < (2 < 3) is false
+ */
+ assertValueOfXPath("true", context, "1 < 2 < 3");
+ /* 0 <= (2 <= 3) is true
+ */
+ assertValueOfXPath("true", context, "2 <= 2 <= 3");
+ }
+ }
+
+ /* test cases for preceding axis with different node types
+ */
+ public void testid53850() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/pi2.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/a/c", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "//processing-instruction()");
+ assertCountXPath(1, context, "preceding-sibling::*");
+ assertCountXPath(5, context, "preceding-sibling::node()");
+ assertCountXPath(1, context, "preceding-sibling::*[1]");
+ assertCountXPath(1, context, "preceding-sibling::processing-instruction()");
+ assertValueOfXPath("order-by=\"x\"", context, "preceding-sibling::processing-instruction()");
+ assertValueOfXPath("foo", context, "preceding-sibling::*[1]");
+ assertValueOfXPath("order-by=\"x\"", context, "preceding-sibling::node()[2]");
+ }
+ }
+
+ public void testid53911() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/id.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ SimpleVariableContext varContext = new SimpleVariableContext();
+ varContext.setVariableValue(null, "foobar", "foobar");
+ varContext.setVariableValue(null, "foo", "foo");
+ getContextSupport().setVariableContext(varContext);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("foobar", context, "$foobar");
+ assertCountXPath(1, context, "/foo[@id=$foobar]");
+ assertCountXPath(0, context, "/foo[@id='$foobar']");
+ assertCountXPath(1, context, "/foo[concat($foo, 'bar')=@id]");
+ assertCountXPath(0, context, "CD_Library/artist[@name=$artist]");
+ }
+ }
+
+ public void testid53957() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/id.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* attributes have a parent: their element
+ */
+ assertCountXPath(1, context, "/foo/@id/parent::foo");
+ }
+ }
+
+ /* attributes can also be used as context nodes
+ */
+ public void testid53975() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/id.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/foo/@id", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "parent::foo");
+ }
+ }
+
+ public void testid53992() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/pi.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(3, context, "//processing-instruction()");
+ assertCountXPath(2, context, "//processing-instruction('cheese')");
+ try
+ {
+ Object result = assertCountXPath2(1, context, "//processing-instruction('toast')");
+ assertValueOfXPath("is tasty", result, "string()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ }
+ }
+
+ /* test evaluate() extension function
+ */
+ public void testid54032() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/evaluate.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(3, context, "evaluate('//jumps/*')");
+ assertCountXPath(1, context, "evaluate('//jumps/object/dog')");
+ assertCountXPath(0, context, "evaluate('//jumps/object')/evaluate");
+ assertCountXPath(1, context, "evaluate('//jumps/object')/dog");
+ assertCountXPath(1, context, "evaluate('//jumps/*')/dog");
+ assertCountXPath(1, context, "//metatest[ evaluate(@select) = . ]");
+ }
+ }
+
+ public void testid54082() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/numbers.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/numbers/set[1]", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "*[-3 = .]");
+ assertValueOfXPath("true", context, "54 < *");
+ assertValueOfXPath("true", context, "55 <= *");
+ assertValueOfXPath("false", context, "69 < *");
+ assertValueOfXPath("true", context, "-2 > *");
+ assertValueOfXPath("true", context, "-3 >= *");
+ assertValueOfXPath("false", context, "-4 >= *");
+ }
+ }
+
+ /* TODO
+ This context should work, but needs a fixed version of saxpath to parse the right-hand side
+ of the greater-than expression.
+ <context select="/numbers/set[2]">
+ <valueOf select="1 > nr/@value">false</valueOf>
+ <valueOf select="55 > nr/@value">false</valueOf>
+ <valueOf select="55 >= nr/@value">true</valueOf>
+ <valueOf select="1000000 > nr/@value">true</valueOf>
+ </context>
+
+ */
+ /* test sibling axes
+ */
+ public void testid54145() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/axis.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(0, context, "preceding-sibling::*");
+ }
+ }
+
+ public void testid54156() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/axis.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root/a/a.3", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(2, context, "preceding::*");
+ }
+ }
+
+ public void testid54168() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/axis.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root/a/a.3", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(2, context, "preceding-sibling::*");
+ }
+ }
+
+ public void testid54180() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/axis.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("a.2", context, "name(/root/a/a.3/preceding-sibling::*[1])");
+ assertValueOfXPath("a.1", context, "name(/root/a/a.3/preceding-sibling::*[2])");
+ }
+ }
+
+ public void testid54197() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/axis.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("a.4", context, "name(/root/a/a.3/following-sibling::*[1])");
+ assertValueOfXPath("a.5", context, "name(/root/a/a.3/following-sibling::*[2])");
+ }
+ }
+
+ public void testid54219() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("snoop", context, "/web-app/servlet[1]/servlet-name");
+ assertValueOfXPath("snoop", context, "/web-app/servlet[1]/servlet-name/text()");
+ assertValueOfXPath("file", context, "/web-app/servlet[2]/servlet-name");
+ assertValueOfXPath("file", context, "/web-app/servlet[2]/servlet-name/text()");
+ }
+ }
+
+ public void testid54249() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/web-app/servlet[1]", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("snoop", context, "servlet-name");
+ assertValueOfXPath("snoop", context, "servlet-name/text()");
+ }
+ }
+
+ public void testid54266() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/web-app/servlet[2]/servlet-name", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(3, context, "preceding::*");
+ }
+ }
+
+ public void testid54278() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/web-app/servlet[2]/servlet-name", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(13, context, "following::*");
+ }
+ }
+
+ /* test name
+ */
+ public void testid54298() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ try
+ {
+ Object result = assertCountXPath2(1, context, "*");
+ assertValueOfXPath("web-app", result, "name()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ /* NOTE that the child::node() tests only work if the
+ XML document does not comments or PIs
+
+ */
+ try
+ {
+ Object result = assertCountXPath2(1, context, "./*");
+ assertValueOfXPath("web-app", result, "name()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ Object result = assertCountXPath2(1, context, "child::*");
+ assertValueOfXPath("web-app", result, "name()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ Object result = assertCountXPath2(1, context, "/*");
+ assertValueOfXPath("web-app", result, "name()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ Object result = assertCountXPath2(1, context, "/child::node()");
+ assertValueOfXPath("web-app", result, "name(.)");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ Object result = assertCountXPath2(1, context, "child::node()");
+ assertValueOfXPath("web-app", result, "name(.)");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ /* empty names
+ */
+ assertValueOfXPath("", context, "name()");
+ assertValueOfXPath("", context, "name(.)");
+ assertValueOfXPath("", context, "name(parent::*)");
+ assertValueOfXPath("", context, "name(/)");
+ assertValueOfXPath("", context, "name(/.)");
+ assertValueOfXPath("", context, "name(/self::node())");
+ /* name of root elemet
+ */
+ assertValueOfXPath("web-app", context, "name(node())");
+ assertValueOfXPath("web-app", context, "name(/node())");
+ assertValueOfXPath("web-app", context, "name(/*)");
+ assertValueOfXPath("web-app", context, "name(/child::*)");
+ assertValueOfXPath("web-app", context, "name(/child::node())");
+ assertValueOfXPath("web-app", context, "name(/child::node())");
+ assertValueOfXPath("web-app", context, "name(child::node())");
+ assertValueOfXPath("web-app", context, "name(./*)");
+ assertValueOfXPath("web-app", context, "name(*)");
+ }
+ }
+
+ public void testid54467() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/*", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* empty names
+ */
+ assertValueOfXPath("", context, "name(..)");
+ assertValueOfXPath("", context, "name(parent::node())");
+ assertValueOfXPath("", context, "name(parent::*)");
+ /* name of root elemet
+ */
+ assertValueOfXPath("web-app", context, "name()");
+ assertValueOfXPath("web-app", context, "name(.)");
+ assertValueOfXPath("web-app", context, "name(../*)");
+ assertValueOfXPath("web-app", context, "name(../child::node())");
+ }
+ }
+
+ /* test predicates
+ */
+ public void testid54522() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/nitf.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/nitf/head/docdata", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "doc-id[@regsrc='AP' and @id-string='D76UIMO80']");
+ }
+ }
+
+ public void testid54534() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/nitf.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/nitf/head", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "meta[@name='ap-cycle']");
+ assertCountXPath(1, context, "meta[@content='AP']");
+ assertCountXPath(8, context, "meta[@name and @content]");
+ assertCountXPath(1, context, "meta[@name='ap-cycle' and @content='AP']");
+ assertCountXPath(7, context, "meta[@name != 'ap-cycle']");
+ }
+ }
+
+ public void testid54570() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/nitf.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/nitf/head/meta[@name='ap-cycle']");
+ assertCountXPath(1, context, "/nitf/head/meta[@content='AP']");
+ assertCountXPath(8, context, "/nitf/head/meta[@name and @content]");
+ assertCountXPath(1, context, "/nitf/head/meta[@name='ap-cycle' and @content='AP']");
+ assertCountXPath(7, context, "/nitf/head/meta[@name != 'ap-cycle']");
+ }
+ }
+
+ public void testid54614() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/moreover.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/child::node()");
+ assertCountXPath(1, context, "/*");
+ assertCountXPath(20, context, "/*/article");
+ assertCountXPath(221, context, "//*");
+ assertCountXPath(20, context, "//*[local-name()='article']");
+ assertCountXPath(20, context, "//article");
+ assertCountXPath(20, context, "/*/*[@code]");
+ assertCountXPath(1, context, "/moreovernews/article[@code='13563275']");
+ try
+ {
+ BaseXPath xpath = new BaseXPath("/moreovernews/article[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ BaseXPath xpath = new BaseXPath("/*/article[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ BaseXPath xpath = new BaseXPath("//article[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ BaseXPath xpath = new BaseXPath("//*[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ BaseXPath xpath = new BaseXPath("/child::node()/child::node()[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ try
+ {
+ BaseXPath xpath = new BaseXPath("/*/*[@code='13563275']", getNavigator());
+ List results = xpath.selectNodes(getContext(context));
+ Object result = results.get(0);
+ assertValueOfXPath("http://c.moreover.com/click/here.pl?x13563273", result, "url");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ }
+ }
+
+ /* test other node types
+ */
+ public void testid54747() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/contents.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(3, context, "processing-instruction()");
+ assertCountXPath(3, context, "/processing-instruction()");
+ assertCountXPath(1, context, "/comment()");
+ assertCountXPath(1, context, "comment()");
+ assertCountXPath(2, context, "/child::node()/comment()");
+ assertCountXPath(2, context, "/*/comment()");
+ assertCountXPath(3, context, "//comment()");
+ }
+ }
+
+ /* test positioning
+ */
+ public void testid54802() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/fibo.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(9, context, "/*/fibonacci[position() < 10]");
+ assertValueOfXPath("196417", context, "sum(//fibonacci)");
+ assertValueOfXPath("325", context, "sum(//fibonacci/@index)");
+ assertValueOfXPath("1", context, "/*/fibonacci[2]");
+ assertValueOfXPath("75025", context, "/*/fibonacci[ count(/*/fibonacci) ]");
+ assertValueOfXPath("46368", context, "/*/fibonacci[ count(/*/fibonacci) - 1 ]");
+ }
+ }
+
+ /* test number functions
+ */
+ /* test Axes
+ */
+ public void testid54853() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(19, context, "descendant-or-self::*");
+ assertCountXPath(19, context, "descendant::*");
+ assertCountXPath(19, context, "/descendant::*");
+ assertCountXPath(19, context, "/descendant-or-self::*");
+ assertCountXPath(2, context, "/descendant::servlet");
+ assertCountXPath(2, context, "/descendant-or-self::servlet");
+ assertCountXPath(2, context, "descendant-or-self::servlet");
+ assertCountXPath(2, context, "descendant::servlet");
+ assertCountXPath(2, context, "/*/servlet");
+ assertValueOfXPath("2", context, "count(/*/servlet)");
+ assertCountXPath(2, context, "//servlet");
+ assertValueOfXPath("2", context, "count(//servlet)");
+ }
+ }
+
+ public void testid54932() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/web-app", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(2, context, "/descendant::servlet");
+ assertCountXPath(2, context, "/descendant-or-self::servlet");
+ assertCountXPath(2, context, "descendant-or-self::servlet");
+ assertCountXPath(2, context, "descendant::servlet");
+ }
+ }
+
+ public void testid54968() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/much_ado.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(5, context, "/descendant::ACT");
+ assertCountXPath(5, context, "descendant::ACT");
+ assertValueOfXPath("Much Ado about Nothing", context, "/PLAY/TITLE");
+ assertValueOfXPath("4", context, "2+2");
+ assertValueOfXPath("21", context, "5 * 4 + 1");
+ assertValueOfXPath("5", context, "count(descendant::ACT)");
+ assertValueOfXPath("35", context, "10 + count(descendant::ACT) * 5");
+ assertValueOfXPath("75", context, "(10 + count(descendant::ACT)) * 5");
+ }
+ }
+
+ public void testid55020() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/much_ado.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/PLAY/ACT[2]/SCENE[1]", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(5, context, "/descendant::ACT");
+ assertCountXPath(5, context, "../../descendant::ACT");
+ assertCountXPath(141, context, "/PLAY/ACT[2]/SCENE[1]/descendant::SPEAKER");
+ assertCountXPath(141, context, "descendant::SPEAKER");
+ assertValueOfXPath("646", context, "count(descendant::*)+1");
+ assertValueOfXPath("142", context, "count(descendant::SPEAKER)+1");
+ assertValueOfXPath("2", context, "count(ancestor::*)");
+ assertValueOfXPath("1", context, "count(ancestor::PLAY)");
+ assertValueOfXPath("3", context, "count(ancestor-or-self::*)");
+ assertValueOfXPath("1", context, "count(ancestor-or-self::PLAY)");
+ assertValueOfXPath("6", context, "5+count(ancestor::*)-1");
+ }
+ }
+
+ public void testid55090() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/much_ado.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* Test correct predicate application
+ */
+ assertValueOfXPath("5", context, "count(/PLAY/ACT/SCENE[1])");
+ }
+ }
+
+ /* test axis node ordering
+ */
+ public void testid55112() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* Reported as Jira issue JAXEN-24
+ */
+ assertCountXPath(1, context, "//servlet-mapping/preceding::*[1][name()='description']");
+ assertCountXPath(1, context, "/web-app/servlet//description/following::*[1][name()='servlet-mapping']");
+ assertCountXPath(1, context, "/web-app/servlet//description/following::*[2][name()='servlet-name']");
+ }
+ }
+
+ /* test document function
+ */
+ public void testid55150() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/text.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ try
+ {
+ Object result = assertCountXPath2(1, context, "document('test-resources/xml/web.xml')");
+ assertValueOfXPath("snoop", result, "/web-app/servlet[1]/servlet-name");
+ assertValueOfXPath("snoop", result, "/web-app/servlet[1]/servlet-name/text()");
+ }
+ catch (UnsupportedAxisException e)
+ {
+ log(debug, " ## SKIPPED -- Unsupported Axis");
+ }
+ assertValueOfXPath("snoop", context, "document('test-resources/xml/web.xml')/web-app/servlet[1]/servlet-name");
+ }
+ }
+
+ /* Test to check if the context changes when an extension function is used.
+ First test is an example, second is the actual test.
+
+ */
+ public void testid55189() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/text.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/foo/bar/cheese[1]", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("3foo3", context, "concat(./@id,'foo',@id)");
+ assertValueOfXPath("3snoop3", context, "concat(./@id,document('test-resources/xml/web.xml')/web-app/servlet[1]/servlet-name,./@id)");
+ }
+ }
+
+ public void testid55211() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/message.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("Pruefgebiete", context, "/message/body/data/items/item[name/text()='parentinfo']/value");
+ assertValueOfXPath("Pruefgebiete", context, "document('test-resources/xml/message.xml')/message/body/data/items/item[name/text()='parentinfo']/value");
+ }
+ }
+
+ /* test behaviour of AbsoluteLocationPath
+ */
+ public void testid55183() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/root/a", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("ab", context, "concat( ., /root/b )");
+ assertValueOfXPath("ba", context, "concat( ../b, . )");
+ assertValueOfXPath("ba", context, "concat( /root/b, . )");
+ assertValueOfXPath("db", context, "concat( /root/c/d, ../b )");
+ }
+ }
+
+ /* test the translate() function
+ */
+ public void testid55268() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("", context, "translate( '', '', '' )");
+ assertValueOfXPath("abcd", context, "translate( 'abcd', '', '' )");
+ assertValueOfXPath("abcd", context, "translate( 'abcd', 'abcd', 'abcd' )");
+ assertValueOfXPath("abcd", context, "translate( 'abcd', 'dcba', 'dcba' )");
+ assertValueOfXPath("dcba", context, "translate( 'abcd', 'abcd', 'dcba' )");
+ assertValueOfXPath("ab", context, "translate( 'abcd', 'abcd', 'ab' )");
+ assertValueOfXPath("cd", context, "translate( 'abcd', 'cdab', 'cd' )");
+ assertValueOfXPath("xy", context, "translate( 'abcd', 'acbd', 'xy' )");
+ assertValueOfXPath("abcd", context, "translate( 'abcd', 'abcdb', 'abcdb' )");
+ assertValueOfXPath("abcd", context, "translate( 'abcd', 'abcd', 'abcdb' )");
+ }
+ }
+
+ public void testid55331() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("234", context, "substring('12345', 1.5, 2.6)");
+ assertValueOfXPath("12", context, "substring('12345', 0, 3)");
+ assertValueOfXPath("", context, "substring('12345', 0 div 0, 3)");
+ assertValueOfXPath("", context, "substring('12345', 1, 0 div 0)");
+ assertValueOfXPath("12345", context, "substring('12345', -42, 1 div 0)");
+ assertValueOfXPath("", context, "substring('12345', -1 div 0, 1 div 0)");
+ assertValueOfXPath("345", context, "substring('12345', 3)");
+ assertValueOfXPath("12345", context, "substring('12345',1,15)");
+ }
+ }
+
+ /* Some tests for the normalize-space() function
+ */
+ public void testid55382() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/simple.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("abc", context, "normalize-space(' abc ')");
+ assertValueOfXPath("a b c", context, "normalize-space(' a b c ')");
+ assertValueOfXPath("a b c", context, "normalize-space(' a \n b \n c')");
+ /* Next test case addresses issue JAXEN-22
+ */
+ assertValueOfXPath("", context, "normalize-space(' ')");
+ /* Next test case addresses issue JAXEN-29
+ */
+ assertValueOfXPath("", context, "normalize-space('')");
+ }
+ }
+
+ /* test cases for String extension functions
+ */
+ public void testid55429() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/web.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/web-app/servlet[1]", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("SNOOPSERVLET", context, "upper-case( servlet-class )");
+ assertValueOfXPath("snoopservlet", context, "lower-case( servlet-class )");
+ assertValueOfXPath("SNOOPSERVLET", context, "upper-case( servlet-class, 'fr' )");
+ assertValueOfXPath("SNOOPSERVLET", context, "upper-case( servlet-class, 'fr-CA' )");
+ assertValueOfXPath("SNOOPSERVLET", context, "upper-case( servlet-class, 'es-ES-Traditional_WIN' )");
+ assertValueOfXPath("true", context, "ends-with( servlet-class, 'Servlet' )");
+ assertValueOfXPath("false", context, "ends-with( servlet-class, 'S' )");
+ }
+ }
+
+ /* test cases for the lang() function
+ */
+ public void testid55485() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/lang.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(0, context, "/e1/e2[lang('hr')]");
+// assertCountXPath(1, context, "/e1/e2/e3[lang('en')]");
+// assertCountXPath(1, context, "/e1/e2/e3[lang('en-US')]");
+ assertCountXPath(0, context, "/e1/e2/e3[lang('en-GB')]");
+ assertCountXPath(2, context, "/e1/e2/e3[lang('hu')]");
+ assertCountXPath(0, context, "/e1/e2/e3[lang('hu-HU')]");
+ assertCountXPath(1, context, "/e1/e2/e3[lang('es')]");
+ assertCountXPath(0, context, "/e1/e2/e3[lang('es-BR')]");
+ }
+ }
+
+ /* test namespace
+ */
+ public void testid55235() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/namespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
+ nsContext.addNamespace("alias", "http://fooNamespace/");
+ nsContext.addNamespace("bar", "http://barNamespace/");
+ nsContext.addNamespace("voo", "http://fooNamespace/");
+ nsContext.addNamespace("foo", "http://fooNamespace/");
+ getContextSupport().setNamespaceContext(nsContext);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/*");
+ assertCountXPath(1, context, "/foo:a");
+ assertCountXPath(1, context, "/foo:a/b");
+ assertCountXPath(1, context, "/voo:a/b/c");
+ assertCountXPath(1, context, "/voo:a/bar:f");
+ assertCountXPath(1, context, "/*[namespace-uri()='http://fooNamespace/' and local-name()='a']");
+ assertCountXPath(1, context, "/*[local-name()='a' and namespace-uri()='http://fooNamespace/']/*[local-name()='x' and namespace-uri()='http://fooNamespace/']");
+ assertCountXPath(1, context, "/*[local-name()='a' and namespace-uri()='http://fooNamespace/']/*[local-name()='x' and namespace-uri()='http://fooNamespace/']/*[local-name()='y' and namespace-uri()='http://fooNamespace/']");
+ }
+ }
+
+ /* the prefix here and in the document have no relation; it's their
+ namespace-uri binding that counts
+ */
+ public void testid55615() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/namespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
+ nsContext.addNamespace("foo", "http://somethingElse/");
+ getContextSupport().setNamespaceContext(nsContext);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(0, context, "/foo:a/b/c");
+ }
+ }
+
+ public void testid55632() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/namespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
+ nsContext.addNamespace("alias", "http://fooNamespace/");
+ nsContext.addNamespace("bar", "http://barNamespace/");
+ nsContext.addNamespace("foo", "http://fooNamespace/");
+ getContextSupport().setNamespaceContext(nsContext);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertValueOfXPath("Hello", context, "/foo:a/b/c");
+ assertValueOfXPath("Hey", context, "/foo:a/foo:d/foo:e");
+ assertValueOfXPath("Hey3", context, "/foo:a/alias:x/alias:y");
+ assertValueOfXPath("Hey3", context, "/foo:a/foo:x/foo:y");
+ assertValueOfXPath("Hey3", context, "/*[local-name()='a' and namespace-uri()='http://fooNamespace/']/*[local-name()='x' and namespace-uri()='http://fooNamespace/']/*[local-name()='y' and namespace-uri()='http://fooNamespace/']");
+ }
+ }
+
+ public void testid55676() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/defaultNamespace.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* NOTE: /a/b/c selects elements in no namespace only!
+ */
+ assertCountXPath(0, context, "/a/b/c");
+ /*
+ The following test uses an unbound prefix 'x' and should throw an exception.
+ Addresses issue JAXEN-18.
+ Turns out this isn't really tested as the test didn't fail when the exception wasn't thrown.
+ <test select="/x:a/x:b/x:c" count="0" exception="true"/>
+
+ */
+ }
+ }
+
+ public void testid55692() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/defaultNamespace.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ SimpleNamespaceContext nsContext = new SimpleNamespaceContext();
+ nsContext.addNamespace("dummy", "http://dummyNamespace/");
+ getContextSupport().setNamespaceContext(nsContext);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "/dummy:a/dummy:b/dummy:c");
+ }
+ }
+
+ public void testid55716() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/text.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(3, context, "/foo/bar/text()");
+ assertValueOfXPath("baz", context, "normalize-space(/foo/bar/text())");
+ }
+ }
+
+ public void testid55739() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/testNamespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* the root is not an element, so no namespaces
+ */
+ assertCountXPath(0, context, "namespace::*");
+ assertCountXPath(0, context, "/namespace::*");
+ /* must count the default xml: prefix as well
+ */
+ assertCountXPath(3, context, "/Template/Application1/namespace::*");
+ assertCountXPath(3, context, "/Template/Application2/namespace::*");
+ /* every element has separate copies
+ */
+ assertCountXPath(25, context, "//namespace::*");
+ }
+ }
+
+ public void testid55797() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/testNamespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/Template/Application1", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* must count the default xml: prefix as well
+ */
+ assertCountXPath(3, context, "namespace::*");
+ assertCountXPath(0, context, "/namespace::*");
+ assertCountXPath(3, context, "/Template/Application1/namespace::*");
+ assertCountXPath(3, context, "/Template/Application2/namespace::*");
+ assertCountXPath(25, context, "//namespace::*");
+ assertCountXPath(8, context, "//namespace::xplt");
+ /* the name test literally matches the prefix as given in the
+ document, and does not use the uri
+ */
+ assertCountXPath(0, context, "//namespace::somethingelse");
+ }
+ }
+
+ public void testid55873() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/testNamespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ /* namespace nodes have their element as their parent
+ */
+ assertCountXPath(1, context, "/Template/namespace::xml/parent::Template");
+ }
+ }
+
+ /* namespace nodes can also be used as context nodes
+ */
+ public void testid55893() throws JaxenException
+ {
+ Navigator nav = getNavigator();
+ String url = TESTS_ROOT + "xml/testNamespaces.xml";
+ log("Document [" + url + "]");
+ Object document = nav.getDocument(url);
+ XPath contextpath = new BaseXPath("/Template/namespace::xml", nav);
+ log("Initial Context :: " + contextpath);
+ List list = contextpath.selectNodes(document);
+ Iterator iter = list.iterator();
+ while (iter.hasNext())
+ {
+ Object context = iter.next();
+ assertCountXPath(1, context, "parent::Template");
+ }
+ }
+}
+
\ No newline at end of file
